How to use Bytes method of got Package

...39		{40			name: "Spends last output of coinbase",41			stxo: SpentTxOut{42				Amount:     5000000000,43				PkScript:   hexToBytes("410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac"),44				IsCoinBase: true,45				Height:     9,46			},47			serialized: hexToBytes("1300320511db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c"),48		},49		// Adapted from block 100025 in main blockchain.50		{51			name: "Spends last output of non coinbase",52			stxo: SpentTxOut{53				Amount:     13761000000,54				PkScript:   hexToBytes("76a914b2fb57eadf61e106a100a7445a8c3f67898841ec88ac"),55				IsCoinBase: false,56				Height:     100024,57			},58			serialized: hexToBytes("8b99700086c64700b2fb57eadf61e106a100a7445a8c3f67898841ec"),59		},60		// Adapted from block 100025 in main blockchain.61		{62			name: "Does not spend last output, legacy format",63			stxo: SpentTxOut{64				Amount:   34405000000,65				PkScript: hexToBytes("76a9146edbc6c4d31bae9f1ccc38538a114bf42de65e8688ac"),66			},67			serialized: hexToBytes("0091f20f006edbc6c4d31bae9f1ccc38538a114bf42de65e86"),68		},69	}70	for _, test := range tests {71		// Ensure the function to calculate the serialized size without actually serializing it is calculated properly.72		gotSize := spentTxOutSerializeSize(&test.stxo)73		if gotSize != len(test.serialized) {74			t.Errorf("SpentTxOutSerializeSize (%s): did not get "+75				"expected size - got %d, want %d", test.name,76				gotSize, len(test.serialized),77			)78			continue79		}80		// Ensure the stxo serializes to the expected value.81		gotSerialized := make([]byte, gotSize)82		gotBytesWritten := putSpentTxOut(gotSerialized, &test.stxo)83		if !bytes.Equal(gotSerialized, test.serialized) {84			t.Errorf("putSpentTxOut (%s): did not get expected "+85				"bytes - got %x, want %x", test.name,86				gotSerialized, test.serialized,87			)88			continue89		}90		if gotBytesWritten != len(test.serialized) {91			t.Errorf("putSpentTxOut (%s): did not get expected "+92				"number of bytes written - got %d, want %d",93				test.name, gotBytesWritten,94				len(test.serialized),95			)96			continue97		}98		// Ensure the serialized bytes are decoded back to the expected stxo.99		var gotStxo SpentTxOut100		gotBytesRead, e := decodeSpentTxOut(test.serialized, &gotStxo)101		if e != nil {102			t.Errorf("decodeSpentTxOut (%s): unexpected error: %v",103				test.name, e,104			)105			continue106		}107		if !reflect.DeepEqual(gotStxo, test.stxo) {108			t.Errorf("decodeSpentTxOut (%s) mismatched entries - "+109				"got %v, want %v", test.name, gotStxo, test.stxo,110			)111			continue112		}113		if gotBytesRead != len(test.serialized) {114			t.Errorf("decodeSpentTxOut (%s): did not get expected "+115				"number of bytes read - got %d, want %d",116				test.name, gotBytesRead, len(test.serialized),117			)118			continue119		}120	}121}122// TestStxoDecodeErrors performs negative tests against decoding spent transaction outputs to ensure error paths work as123// expected.124func TestStxoDecodeErrors(t *testing.T) {125	t.Parallel()126	tests := []struct {127		name       string128		stxo       SpentTxOut129		serialized []byte130		bytesRead  int131		errType    error132	}{133		{134			name:       "nothing serialized",135			stxo:       SpentTxOut{},136			serialized: hexToBytes(""),137			errType:    errDeserialize(""),138			bytesRead:  0,139		},140		{141			name:       "no data after header code w/o reserved",142			stxo:       SpentTxOut{},143			serialized: hexToBytes("00"),144			errType:    errDeserialize(""),145			bytesRead:  1,146		},147		{148			name:       "no data after header code with reserved",149			stxo:       SpentTxOut{},150			serialized: hexToBytes("13"),151			errType:    errDeserialize(""),152			bytesRead:  1,153		},154		{155			name:       "no data after reserved",156			stxo:       SpentTxOut{},157			serialized: hexToBytes("1300"),158			errType:    errDeserialize(""),159			bytesRead:  2,160		},161		{162			name:       "incomplete compressed txout",163			stxo:       SpentTxOut{},164			serialized: hexToBytes("1332"),165			errType:    errDeserialize(""),166			bytesRead:  2,167		},168	}169	for _, test := range tests {170		// Ensure the expected error type is returned.171		gotBytesRead, e := decodeSpentTxOut(test.serialized,172			&test.stxo,173		)174		if reflect.TypeOf(e) != reflect.TypeOf(test.errType) {175			t.Errorf("decodeSpentTxOut (%s): expected error type "+176				"does not match - got %T, want %T", test.name,177				e, test.errType,178			)179			continue180		}181		// Ensure the expected number of bytes read is returned.182		if gotBytesRead != test.bytesRead {183			t.Errorf("decodeSpentTxOut (%s): unexpected number of "+184				"bytes read - got %d, want %d", test.name,185				gotBytesRead, test.bytesRead,186			)187			continue188		}189	}190}191// TestSpendJournalSerialization ensures serializing and deserializing spend journal entries works as expected.192func TestSpendJournalSerialization(t *testing.T) {193	t.Parallel()194	tests := []struct {195		name       string196		entry      []SpentTxOut197		blockTxns  []*wire.MsgTx198		serialized []byte199	}{200		// From block 2 in main blockchain.201		{202			name:       "No spends",203			entry:      nil,204			blockTxns:  nil,205			serialized: nil,206		},207		// From block 170 in main blockchain.208		{209			name: "One tx with one input spends last output of coinbase",210			entry: []SpentTxOut{{211				Amount:     5000000000,212				PkScript:   hexToBytes("410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac"),213				IsCoinBase: true,214				Height:     9,215			},216			},217			blockTxns: []*wire.MsgTx{{ // Coinbase omitted.218				Version: 1,219				TxIn: []*wire.TxIn{{220					PreviousOutPoint: wire.OutPoint{221						Hash:  *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"),222						Index: 0,223					},224					SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"),225					Sequence:        0xffffffff,226				},227				},228				TxOut: []*wire.TxOut{{229					Value:    1000000000,230					PkScript: hexToBytes("4104ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414e7aab37397f554a7df5f142c21c1b7303b8a0626f1baded5c72a704f7e6cd84cac"),231				},232					{233						Value:    4000000000,234						PkScript: hexToBytes("410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac"),235					},236				},237				LockTime: 0,238			},239			},240			serialized: hexToBytes("1300320511db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c"),241		},242		// Adapted from block 100025 in main blockchain.243		{244			name: "Two txns when one spends last output, one doesn't",245			entry: []SpentTxOut{{246				Amount:     34405000000,247				PkScript:   hexToBytes("76a9146edbc6c4d31bae9f1ccc38538a114bf42de65e8688ac"),248				IsCoinBase: false,249				Height:     100024,250			},251				{252					Amount:     13761000000,253					PkScript:   hexToBytes("76a914b2fb57eadf61e106a100a7445a8c3f67898841ec88ac"),254					IsCoinBase: false,255					Height:     100024,256				},257			},258			blockTxns: []*wire.MsgTx{{ // Coinbase omitted.259				Version: 1,260				TxIn: []*wire.TxIn{{261					PreviousOutPoint: wire.OutPoint{262						Hash:  *newHashFromStr("c0ed017828e59ad5ed3cf70ee7c6fb0f426433047462477dc7a5d470f987a537"),263						Index: 1,264					},265					SignatureScript: hexToBytes("493046022100c167eead9840da4a033c9a56470d7794a9bb1605b377ebe5688499b39f94be59022100fb6345cab4324f9ea0b9ee9169337534834638d818129778370f7d378ee4a325014104d962cac5390f12ddb7539507065d0def320d68c040f2e73337c3a1aaaab7195cb5c4d02e0959624d534f3c10c3cf3d73ca5065ebd62ae986b04c6d090d32627c"),266					Sequence:        0xffffffff,267				},268				},269				TxOut: []*wire.TxOut{{270					Value:    5000000,271					PkScript: hexToBytes("76a914f419b8db4ba65f3b6fcc233acb762ca6f51c23d488ac"),272				},273					{274						Value:    34400000000,275						PkScript: hexToBytes("76a914cadf4fc336ab3c6a4610b75f31ba0676b7f663d288ac"),276					},277				},278				LockTime: 0,279			},280				{281					Version: 1,282					TxIn: []*wire.TxIn{{283						PreviousOutPoint: wire.OutPoint{284							Hash:  *newHashFromStr("92fbe1d4be82f765dfabc9559d4620864b05cc897c4db0e29adac92d294e52b7"),285							Index: 0,286						},287						SignatureScript: hexToBytes("483045022100e256743154c097465cf13e89955e1c9ff2e55c46051b627751dee0144183157e02201d8d4f02cde8496aae66768f94d35ce54465bd4ae8836004992d3216a93a13f00141049d23ce8686fe9b802a7a938e8952174d35dd2c2089d4112001ed8089023ab4f93a3c9fcd5bfeaa9727858bf640dc1b1c05ec3b434bb59837f8640e8810e87742"),288						Sequence:        0xffffffff,289					},290					},291					TxOut: []*wire.TxOut{{292						Value:    5000000,293						PkScript: hexToBytes("76a914a983ad7c92c38fc0e2025212e9f972204c6e687088ac"),294					},295						{296							Value:    13756000000,297							PkScript: hexToBytes("76a914a6ebd69952ab486a7a300bfffdcb395dc7d47c2388ac"),298						},299					},300					LockTime: 0,301				},302			},303			serialized: hexToBytes("8b99700086c64700b2fb57eadf61e106a100a7445a8c3f67898841ec8b99700091f20f006edbc6c4d31bae9f1ccc38538a114bf42de65e86"),304		},305	}306	for i, test := range tests {307		// Ensure the journal entry serializes to the expected value.308		gotBytes := serializeSpendJournalEntry(test.entry)309		if !bytes.Equal(gotBytes, test.serialized) {310			t.Errorf("serializeSpendJournalEntry #%d (%s): "+311				"mismatched bytes - got %x, want %x", i,312				test.name, gotBytes, test.serialized,313			)314			continue315		}316		// Deserialize to a spend journal entry.317		gotEntry, e := deserializeSpendJournalEntry(test.serialized,318			test.blockTxns,319		)320		if e != nil {321			t.Errorf("deserializeSpendJournalEntry #%d (%s) "+322				"unexpected error: %v", i, test.name, e,323			)324			continue325		}326		// Ensure that the deserialized spend journal entry has the327		// correct properties.328		if !reflect.DeepEqual(gotEntry, test.entry) {329			t.Errorf("deserializeSpendJournalEntry #%d (%s) "+330				"mismatched entries - got %v, want %v",331				i, test.name, gotEntry, test.entry,332			)333			continue334		}335	}336}337// TestSpendJournalErrors performs negative tests against deserializing spend journal entries to ensure error paths work338// as expected.339func TestSpendJournalErrors(t *testing.T) {340	t.Parallel()341	tests := []struct {342		name       string343		blockTxns  []*wire.MsgTx344		serialized []byte345		errType    error346	}{347		// Adapted from block 170 in main blockchain.348		{349			name: "Force assertion due to missing stxos",350			blockTxns: []*wire.MsgTx{{ // Coinbase omitted.351				Version: 1,352				TxIn: []*wire.TxIn{{353					PreviousOutPoint: wire.OutPoint{354						Hash:  *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"),355						Index: 0,356					},357					SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"),358					Sequence:        0xffffffff,359				},360				},361				LockTime: 0,362			},363			},364			serialized: hexToBytes(""),365			errType:    AssertError(""),366		},367		{368			name: "Force deserialization error in stxos",369			blockTxns: []*wire.MsgTx{{ // Coinbase omitted.370				Version: 1,371				TxIn: []*wire.TxIn{{372					PreviousOutPoint: wire.OutPoint{373						Hash:  *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"),374						Index: 0,375					},376					SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"),377					Sequence:        0xffffffff,378				},379				},380				LockTime: 0,381			},382			},383			serialized: hexToBytes("1301320511db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a"),384			errType:    errDeserialize(""),385		},386	}387	for _, test := range tests {388		// Ensure the expected error type is returned and the returned slice is nil.389		stxos, e := deserializeSpendJournalEntry(test.serialized,390			test.blockTxns,391		)392		if reflect.TypeOf(e) != reflect.TypeOf(test.errType) {393			t.Errorf("deserializeSpendJournalEntry (%s): expected "+394				"error type does not match - got %T, want %T",395				test.name, e, test.errType,396			)397			continue398		}399		if stxos != nil {400			t.Errorf("deserializeSpendJournalEntry (%s): returned "+401				"slice of spent transaction outputs is not nil",402				test.name,403			)404			continue405		}406	}407}408// TestUtxoSerialization ensures serializing and deserializing unspent trasaction output entries works as expected.409func TestUtxoSerialization(t *testing.T) {410	t.Parallel()411	tests := []struct {412		name       string413		entry      *UtxoEntry414		serialized []byte415	}{416		// From tx in main blockchain: 0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098:0417		{418			name: "height 1, coinbase",419			entry: &UtxoEntry{420				amount:      5000000000,421				pkScript:    hexToBytes("410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac"),422				blockHeight: 1,423				packedFlags: tfCoinBase,424			},425			serialized: hexToBytes("03320496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52"),426		},427		// From tx in main blockchain: 0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098:0428		{429			name: "height 1, coinbase, spent",430			entry: &UtxoEntry{431				amount:      5000000000,432				pkScript:    hexToBytes("410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac"),433				blockHeight: 1,434				packedFlags: tfCoinBase | tfSpent,435			},436			serialized: nil,437		},438		// From tx in main blockchain: 8131ffb0a2c945ecaf9b9063e59558784f9c3a74741ce6ae2a18d0571dac15bb:1439		{440			name: "height 100001, not coinbase",441			entry: &UtxoEntry{442				amount:      1000000,443				pkScript:    hexToBytes("76a914ee8bd501094a7d5ca318da2506de35e1cb025ddc88ac"),444				blockHeight: 100001,445				packedFlags: 0,446			},447			serialized: hexToBytes("8b99420700ee8bd501094a7d5ca318da2506de35e1cb025ddc"),448		},449		// From tx in main blockchain: 8131ffb0a2c945ecaf9b9063e59558784f9c3a74741ce6ae2a18d0571dac15bb:1450		{451			name: "height 100001, not coinbase, spent",452			entry: &UtxoEntry{453				amount:      1000000,454				pkScript:    hexToBytes("76a914ee8bd501094a7d5ca318da2506de35e1cb025ddc88ac"),455				blockHeight: 100001,456				packedFlags: tfSpent,457			},458			serialized: nil,459		},460	}461	for i, test := range tests {462		// Ensure the utxo entry serializes to the expected value.463		gotBytes, e := serializeUtxoEntry(test.entry)464		if e != nil {465			t.Errorf("serializeUtxoEntry #%d (%s) unexpected "+466				"error: %v", i, test.name, e,467			)468			continue469		}470		if !bytes.Equal(gotBytes, test.serialized) {471			t.Errorf("serializeUtxoEntry #%d (%s): mismatched "+472				"bytes - got %x, want %x", i, test.name,473				gotBytes, test.serialized,474			)475			continue476		}477		// Don't try to deserialize if the test entry was spent since it will have a nil serialization.478		if test.entry.IsSpent() {479			continue480		}481		// Deserialize to a utxo entry.482		utxoEntry, e := deserializeUtxoEntry(test.serialized)483		if e != nil {484			t.Errorf("deserializeUtxoEntry #%d (%s) unexpected "+485				"error: %v", i, test.name, e,486			)487			continue488		}489		// The deserialized entry must not be marked spent since unspent entries are not serialized.490		if utxoEntry.IsSpent() {491			t.Errorf("deserializeUtxoEntry #%d (%s) output should "+492				"not be marked spent", i, test.name,493			)494			continue495		}496		// Ensure the deserialized entry has the same properties as the ones in the test entry.497		if utxoEntry.Amount() != test.entry.Amount() {498			t.Errorf("deserializeUtxoEntry #%d (%s) mismatched "+499				"amounts: got %d, want %d", i, test.name,500				utxoEntry.Amount(), test.entry.Amount(),501			)502			continue503		}504		if !bytes.Equal(utxoEntry.PkScript(), test.entry.PkScript()) {505			t.Errorf("deserializeUtxoEntry #%d (%s) mismatched "+506				"scripts: got %x, want %x", i, test.name,507				utxoEntry.PkScript(), test.entry.PkScript(),508			)509			continue510		}511		if utxoEntry.BlockHeight() != test.entry.BlockHeight() {512			t.Errorf("deserializeUtxoEntry #%d (%s) mismatched "+513				"block height: got %d, want %d", i, test.name,514				utxoEntry.BlockHeight(), test.entry.BlockHeight(),515			)516			continue517		}518		if utxoEntry.IsCoinBase() != test.entry.IsCoinBase() {519			t.Errorf("deserializeUtxoEntry #%d (%s) mismatched "+520				"coinbase flag: got %v, want %v", i, test.name,521				utxoEntry.IsCoinBase(), test.entry.IsCoinBase(),522			)523			continue524		}525	}526}527// TestUtxoEntryHeaderCodeErrors performs negative tests against unspent transaction output header codes to ensure error528// paths work as expected.529func TestUtxoEntryHeaderCodeErrors(t *testing.T) {530	t.Parallel()531	tests := []struct {532		name  string533		entry *UtxoEntry534		// code    uint64535		errType error536	}{537		{538			name:    "Force assertion due to spent output",539			entry:   &UtxoEntry{packedFlags: tfSpent},540			errType: AssertError(""),541		},542	}543	for _, test := range tests {544		// Ensure the expected error type is returned and the code is 0.545		code, e := utxoEntryHeaderCode(test.entry)546		if reflect.TypeOf(e) != reflect.TypeOf(test.errType) {547			t.Errorf("utxoEntryHeaderCode (%s): expected error "+548				"type does not match - got %T, want %T",549				test.name, e, test.errType,550			)551			continue552		}553		if code != 0 {554			t.Errorf("utxoEntryHeaderCode (%s): unexpected code "+555				"on error - got %d, want 0", test.name, code,556			)557			continue558		}559	}560}561// TestUtxoEntryDeserializeErrors performs negative tests against deserializing unspent transaction outputs to ensure562// error paths work as expected.563func TestUtxoEntryDeserializeErrors(t *testing.T) {564	t.Parallel()565	tests := []struct {566		name       string567		serialized []byte568		errType    error569	}{570		{571			name:       "no data after header code",572			serialized: hexToBytes("02"),573			errType:    errDeserialize(""),574		},575		{576			name:       "incomplete compressed txout",577			serialized: hexToBytes("0232"),578			errType:    errDeserialize(""),579		},580	}581	for _, test := range tests {582		// Ensure the expected error type is returned and the returned entry is nil.583		entry, e := deserializeUtxoEntry(test.serialized)584		if reflect.TypeOf(e) != reflect.TypeOf(test.errType) {585			t.Errorf("deserializeUtxoEntry (%s): expected error "+586				"type does not match - got %T, want %T",587				test.name, e, test.errType,588			)589			continue590		}591		if entry != nil {592			t.Errorf("deserializeUtxoEntry (%s): returned entry "+593				"is not nil", test.name,594			)595			continue596		}597	}598}599// // TestBestChainStateSerialization ensures serializing and deserializing the best chain state works as expected.600// func TestBestChainStateSerialization(// 	t *testing.T) {601// 	t.Parallel()602// 	workSum := new(big.Int)603// 	tests := []struct {604// 		name       string605// 		state      bestChainState606// 		serialized []byte607// 	}{608// 		{609// 			name: "genesis",610// 			state: bestChainState{611// 				hash:      *newHashFromStr("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"),612// 				height:    0,613// 				totalTxns: 1,614// 				workSum: func() *big.Int {615// 					workSum.Add(workSum, CalcWork(486604799, 0, 2))616// 					return new(big.Int).Set(workSum)617// 				}(),618// 				// 0x0100010001619// 			},620// 			serialized: hexToBytes("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000100000000000000050000000100010001"),621// 		},622// 		{623// 			name: "block 1",624// 			state: bestChainState{625// 				hash:      *newHashFromStr("00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048"),626// 				height:    1,627// 				totalTxns: 2,628// 				workSum: func() *big.Int {629// 					workSum.Add(workSum, CalcWork(486604799, 1, 2))630// 					return new(big.Int).Set(workSum)631// 				}(),632// 				// 0x0200020002633// 			},634// 			serialized: hexToBytes("4860eb18bf1b1620e37e9490fc8a427514416fd75159ab86688e9a8300000000010000000200000000000000050000000200020002"),635// 		},636// 	}637// 	for i, test := range tests {638// 		// Ensure the state serializes to the expected value.639// 		gotBytes := serializeBestChainState(test.state)640// 		if !bytes.Equal(gotBytes, test.serialized) {641// 			t.Errorf("serializeBestChainState #%d (%s): mismatched "+642// 				"bytes - got %x, want %x", i, test.name,643// 				gotBytes, test.serialized)644// 			continue645// 		}646// 		// Ensure the serialized bytes are decoded back to the expected state.647// 		state, e := deserializeBestChainState(test.serialized)648// 		if e != nil  {649// 			t.Errorf("deserializeBestChainState #%d (%s) "+650// 				"unexpected error: %v", i, test.name, e)651// 			continue652// 		}653// 		if !reflect.DeepEqual(state, test.state) {654// 			t.Errorf("deserializeBestChainState #%d (%s) "+655// 				"mismatched state - got %v, want %v", i,656// 				test.name, state, test.state)657// 			continue658// 		}659// 	}660// }661// TestBestChainStateDeserializeErrors performs negative tests against deserializing the chain state to ensure error662// paths work as expected.663func TestBestChainStateDeserializeErrors(t *testing.T) {664	t.Parallel()665	tests := []struct {666		name       string667		serialized []byte668		errType    error669	}{670		{671			name:       "nothing serialized",672			serialized: hexToBytes(""),673			errType:    database.DBError{ErrorCode: database.ErrCorruption},674		},675		{676			name:       "short data in hash",677			serialized: hexToBytes("0000"),678			errType:    database.DBError{ErrorCode: database.ErrCorruption},679		},680		{681			name:       "short data in work sum",682			serialized: hexToBytes("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000001000000000000000500000001000100"),683			errType:    database.DBError{ErrorCode: database.ErrCorruption},684		},685	}686	for _, test := range tests {687		// Ensure the expected error type and code is returned.688		_, e := deserializeBestChainState(test.serialized)689		if reflect.TypeOf(e) != reflect.TypeOf(test.errType) {690			t.Errorf("deserializeBestChainState (%s): expected "+691				"error type does not match - got %T, want %T",692				test.name, e, test.errType,693			)694			continue695		}696		if derr, ok := e.(database.DBError); ok {...

...3	"bytes"4	"encoding/hex"5	"testing"6)7// hexToBytes converts the passed hex string into bytes and will panic if there is an error. This is only provided for8// the hard-coded constants so errors in the source code can be detected. It will only (and must only) be called with9// hard-coded values.10func hexToBytes(s string) []byte {11	b, e := hex.DecodeString(s)12	if e != nil {13		panic("invalid hex in source file: " + s)14	}15	return b16}17// TestVLQ ensures the variable length quantity serialization, deserialization, and size calculation works as expected.18func TestVLQ(t *testing.T) {19	t.Parallel()20	tests := []struct {21		val        uint6422		serialized []byte23	}{24		{0, hexToBytes("00")},25		{1, hexToBytes("01")},26		{127, hexToBytes("7f")},27		{128, hexToBytes("8000")},28		{129, hexToBytes("8001")},29		{255, hexToBytes("807f")},30		{256, hexToBytes("8100")},31		{16383, hexToBytes("fe7f")},32		{16384, hexToBytes("ff00")},33		{16511, hexToBytes("ff7f")}, // Max 2-byte value34		{16512, hexToBytes("808000")},35		{16513, hexToBytes("808001")},36		{16639, hexToBytes("80807f")},37		{32895, hexToBytes("80ff7f")},38		{2113663, hexToBytes("ffff7f")}, // Max 3-byte value39		{2113664, hexToBytes("80808000")},40		{270549119, hexToBytes("ffffff7f")}, // Max 4-byte value41		{270549120, hexToBytes("8080808000")},42		{2147483647, hexToBytes("86fefefe7f")},43		{2147483648, hexToBytes("86fefeff00")},44		{4294967295, hexToBytes("8efefefe7f")}, // Max uint32, 5 bytes45		// Max uint64, 10 bytes46		{18446744073709551615, hexToBytes("80fefefefefefefefe7f")},47	}48	for _, test := range tests {49		// Ensure the function to calculate the serialized size without actually serializing the value is calculated50		// properly.51		gotSize := serializeSizeVLQ(test.val)52		if gotSize != len(test.serialized) {53			t.Errorf("serializeSizeVLQ: did not get expected size "+54				"for %d - got %d, want %d", test.val, gotSize,55				len(test.serialized),56			)57			continue58		}59		// Ensure the value serializes to the expected bytes.60		gotBytes := make([]byte, gotSize)61		gotBytesWritten := putVLQ(gotBytes, test.val)62		if !bytes.Equal(gotBytes, test.serialized) {63			t.Errorf("putVLQUnchecked: did not get expected bytes "+64				"for %d - got %x, want %x", test.val, gotBytes,65				test.serialized,66			)67			continue68		}69		if gotBytesWritten != len(test.serialized) {70			t.Errorf("putVLQUnchecked: did not get expected number "+71				"of bytes written for %d - got %d, want %d",72				test.val, gotBytesWritten, len(test.serialized),73			)74			continue75		}76		// Ensure the serialized bytes deserialize to the expected value.77		gotVal, gotBytesRead := deserializeVLQ(test.serialized)78		if gotVal != test.val {79			t.Errorf("deserializeVLQ: did not get expected value "+80				"for %x - got %d, want %d", test.serialized,81				gotVal, test.val,82			)83			continue84		}85		if gotBytesRead != len(test.serialized) {86			t.Errorf("deserializeVLQ: did not get expected number "+87				"of bytes read for %d - got %d, want %d",88				test.serialized, gotBytesRead,89				len(test.serialized),90			)91			continue92		}93	}94}95// TestScriptCompression ensures the domain-specific script compression and decompression works as expected.96func TestScriptCompression(t *testing.T) {97	t.Parallel()98	tests := []struct {99		name         string100		uncompressed []byte101		compressed   []byte102	}{103		{104			name:         "nil",105			uncompressed: nil,106			compressed:   hexToBytes("06"),107		},108		{109			name:         "pay-to-pubkey-hash 1",110			uncompressed: hexToBytes("76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac"),111			compressed:   hexToBytes("001018853670f9f3b0582c5b9ee8ce93764ac32b93"),112		},113		{114			name:         "pay-to-pubkey-hash 2",115			uncompressed: hexToBytes("76a914e34cce70c86373273efcc54ce7d2a491bb4a0e8488ac"),116			compressed:   hexToBytes("00e34cce70c86373273efcc54ce7d2a491bb4a0e84"),117		},118		{119			name:         "pay-to-script-hash 1",120			uncompressed: hexToBytes("a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87"),121			compressed:   hexToBytes("01da1745e9b549bd0bfa1a569971c77eba30cd5a4b"),122		},123		{124			name:         "pay-to-script-hash 2",125			uncompressed: hexToBytes("a914f815b036d9bbbce5e9f2a00abd1bf3dc91e9551087"),126			compressed:   hexToBytes("01f815b036d9bbbce5e9f2a00abd1bf3dc91e95510"),127		},128		{129			name:         "pay-to-pubkey compressed 0x02",130			uncompressed: hexToBytes("2102192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4ac"),131			compressed:   hexToBytes("02192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),132		},133		{134			name:         "pay-to-pubkey compressed 0x03",135			uncompressed: hexToBytes("2103b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65ac"),136			compressed:   hexToBytes("03b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65"),137		},138		{139			name:         "pay-to-pubkey uncompressed 0x04 even",140			uncompressed: hexToBytes("4104192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b40d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453eac"),141			compressed:   hexToBytes("04192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),142		},143		{144			name:         "pay-to-pubkey uncompressed 0x04 odd",145			uncompressed: hexToBytes("410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac"),146			compressed:   hexToBytes("0511db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c"),147		},148		{149			name:         "pay-to-pubkey invalid pubkey",150			uncompressed: hexToBytes("3302aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"),151			compressed:   hexToBytes("293302aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"),152		},153		{154			name:         "null data",155			uncompressed: hexToBytes("6a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),156			compressed:   hexToBytes("286a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),157		},158		{159			name:         "requires 2 size bytes - data push 200 bytes",160			uncompressed: append(hexToBytes("4cc8"), bytes.Repeat([]byte{0x00}, 200)...),161			// [0x80, 0x50] = 208 as a variable length quantity162			// [0x4c, 0xc8] = OP_PUSHDATA1 200163			compressed: append(hexToBytes("80504cc8"), bytes.Repeat([]byte{0x00}, 200)...),164		},165	}166	for _, test := range tests {167		// Ensure the function to calculate the serialized size without actually serializing the value is calculated168		// properly.169		gotSize := compressedScriptSize(test.uncompressed)170		if gotSize != len(test.compressed) {171			t.Errorf("compressedScriptSize (%s): did not get "+172				"expected size - got %d, want %d", test.name,173				gotSize, len(test.compressed),174			)175			continue176		}177		// Ensure the script compresses to the expected bytes.178		gotCompressed := make([]byte, gotSize)179		gotBytesWritten := putCompressedScript(gotCompressed,180			test.uncompressed,181		)182		if !bytes.Equal(gotCompressed, test.compressed) {183			t.Errorf("putCompressedScript (%s): did not get "+184				"expected bytes - got %x, want %x", test.name,185				gotCompressed, test.compressed,186			)187			continue188		}189		if gotBytesWritten != len(test.compressed) {190			t.Errorf("putCompressedScript (%s): did not get "+191				"expected number of bytes written - got %d, "+192				"want %d", test.name, gotBytesWritten,193				len(test.compressed),194			)195			continue196		}197		// Ensure the compressed script size is properly decoded from the compressed script.198		gotDecodedSize := decodeCompressedScriptSize(test.compressed)199		if gotDecodedSize != len(test.compressed) {200			t.Errorf("decodeCompressedScriptSize (%s): did not get "+201				"expected size - got %d, want %d", test.name,202				gotDecodedSize, len(test.compressed),203			)204			continue205		}206		// Ensure the script decompresses to the expected bytes.207		gotDecompressed := decompressScript(test.compressed)208		if !bytes.Equal(gotDecompressed, test.uncompressed) {209			t.Errorf("decompressScript (%s): did not get expected "+210				"bytes - got %x, want %x", test.name,211				gotDecompressed, test.uncompressed,212			)213			continue214		}215	}216}217// TestScriptCompressionErrors ensures calling various functions related to script compression with incorrect data218// returns the expected results.219func TestScriptCompressionErrors(t *testing.T) {220	t.Parallel()221	// A nil script must result in a decoded size of 0.222	if gotSize := decodeCompressedScriptSize(nil); gotSize != 0 {223		t.Fatalf("decodeCompressedScriptSize with nil script did not "+224			"return 0 - got %d", gotSize,225		)226	}227	// A nil script must result in a nil decompressed script.228	if gotScript := decompressScript(nil); gotScript != nil {229		t.Fatalf("decompressScript with nil script did not return nil "+230			"decompressed script - got %x", gotScript,231		)232	}233	// A compressed script for a pay-to-pubkey (uncompressed) that results in an invalid pubkey must result in a nil234	// decompressed script.235	compressedScript := hexToBytes("04012d74d0cb94344c9569c2e77901573d8d" +236		"7903c3ebec3a957724895dca52c6b4",237	)238	if gotScript := decompressScript(compressedScript); gotScript != nil {239		t.Fatalf("decompressScript with compressed pay-to-"+240			"uncompressed-pubkey that is invalid did not return "+241			"nil decompressed script - got %x", gotScript,242		)243	}244}245// TestAmountCompression ensures the domain-specific transaction output amount compression and decompression works as246// expected.247func TestAmountCompression(t *testing.T) {248	t.Parallel()249	tests := []struct {250		name         string251		uncompressed uint64252		compressed   uint64253	}{254		{255			name:         "0 DUO (sometimes used in nulldata)",256			uncompressed: 0,257			compressed:   0,258		},259		{260			name:         "546 Satoshi (current network dust value)",261			uncompressed: 546,262			compressed:   4911,263		},264		{265			name:         "0.00001 DUO (typical transaction fee)",266			uncompressed: 1000,267			compressed:   4,268		},269		{270			name:         "0.0001 DUO (typical transaction fee)",271			uncompressed: 10000,272			compressed:   5,273		},274		{275			name:         "0.12345678 DUO",276			uncompressed: 12345678,277			compressed:   111111101,278		},279		{280			name:         "0.5 DUO",281			uncompressed: 50000000,282			compressed:   48,283		},284		{285			name:         "1 DUO",286			uncompressed: 100000000,287			compressed:   9,288		},289		{290			name:         "5 DUO",291			uncompressed: 500000000,292			compressed:   49,293		},294		{295			name:         "21000000 DUO (max minted coins)",296			uncompressed: 2100000000000000,297			compressed:   21000000,298		},299	}300	for _, test := range tests {301		// Ensure the amount compresses to the expected value.302		gotCompressed := compressTxOutAmount(test.uncompressed)303		if gotCompressed != test.compressed {304			t.Errorf("compressTxOutAmount (%s): did not get "+305				"expected value - got %d, want %d", test.name,306				gotCompressed, test.compressed,307			)308			continue309		}310		// Ensure the value decompresses to the expected value.311		gotDecompressed := decompressTxOutAmount(test.compressed)312		if gotDecompressed != test.uncompressed {313			t.Errorf("decompressTxOutAmount (%s): did not get "+314				"expected value - got %d, want %d", test.name,315				gotDecompressed, test.uncompressed,316			)317			continue318		}319	}320}321// TestCompressedTxOut ensures the transaction output serialization and deserialization works as expected.322func TestCompressedTxOut(t *testing.T) {323	t.Parallel()324	tests := []struct {325		name       string326		amount     uint64327		pkScript   []byte328		compressed []byte329	}{330		{331			name:       "nulldata with 0 DUO",332			amount:     0,333			pkScript:   hexToBytes("6a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),334			compressed: hexToBytes("00286a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),335		},336		{337			name:       "pay-to-pubkey-hash dust",338			amount:     546,339			pkScript:   hexToBytes("76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac"),340			compressed: hexToBytes("a52f001018853670f9f3b0582c5b9ee8ce93764ac32b93"),341		},342		{343			name:       "pay-to-pubkey uncompressed 1 DUO",344			amount:     100000000,345			pkScript:   hexToBytes("4104192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b40d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453eac"),346			compressed: hexToBytes("0904192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),347		},348	}349	for _, test := range tests {350		// Ensure the function to calculate the serialized size without actually serializing the txout is calculated351		// properly.352		gotSize := compressedTxOutSize(test.amount, test.pkScript)353		if gotSize != len(test.compressed) {354			t.Errorf("compressedTxOutSize (%s): did not get "+355				"expected size - got %d, want %d", test.name,356				gotSize, len(test.compressed),357			)358			continue359		}360		// Ensure the txout compresses to the expected value.361		gotCompressed := make([]byte, gotSize)362		gotBytesWritten := putCompressedTxOut(gotCompressed,363			test.amount, test.pkScript,364		)365		if !bytes.Equal(gotCompressed, test.compressed) {366			t.Errorf("compressTxOut (%s): did not get expected "+367				"bytes - got %x, want %x", test.name,368				gotCompressed, test.compressed,369			)370			continue371		}372		if gotBytesWritten != len(test.compressed) {373			t.Errorf("compressTxOut (%s): did not get expected "+374				"number of bytes written - got %d, want %d",375				test.name, gotBytesWritten,376				len(test.compressed),377			)378			continue379		}380		// Ensure the serialized bytes are decoded back to the expected uncompressed values.381		gotAmount, gotScript, gotBytesRead, e := decodeCompressedTxOut(382			test.compressed,383		)384		if e != nil {385			t.Errorf("decodeCompressedTxOut (%s): unexpected "+386				"error: %v", test.name, e,387			)388			continue389		}390		if gotAmount != test.amount {391			t.Errorf("decodeCompressedTxOut (%s): did not get "+392				"expected amount - got %d, want %d",393				test.name, gotAmount, test.amount,394			)395			continue396		}397		if !bytes.Equal(gotScript, test.pkScript) {398			t.Errorf("decodeCompressedTxOut (%s): did not get "+399				"expected script - got %x, want %x",400				test.name, gotScript, test.pkScript,401			)402			continue403		}404		if gotBytesRead != len(test.compressed) {405			t.Errorf("decodeCompressedTxOut (%s): did not get "+406				"expected number of bytes read - got %d, want %d",407				test.name, gotBytesRead, len(test.compressed),408			)409			continue410		}411	}412}413// TestTxOutCompressionErrors ensures calling various functions related to txout compression with incorrect data returns414// the expected results.415func TestTxOutCompressionErrors(t *testing.T) {416	t.Parallel()417	// A compressed txout with missing compressed script must error.418	compressedTxOut := hexToBytes("00")419	_, _, _, e := decodeCompressedTxOut(compressedTxOut)420	if !isDeserializeErr(e) {421		t.Fatalf("decodeCompressedTxOut with missing compressed script "+422			"did not return expected error type - got %T, want "+423			"errDeserialize", e,424		)425	}426	// A compressed txout with short compressed script must error.427	compressedTxOut = hexToBytes("0010")428	_, _, _, e = decodeCompressedTxOut(compressedTxOut)429	if !isDeserializeErr(e) {430		t.Fatalf("decodeCompressedTxOut with short compressed script "+431			"did not return expected error type - got %T, want "+432			"errDeserialize", e,433		)434	}435}...

...306	if got != want {307		t.Fatalf("Marshal: got %s want %s", got, want)308	}309}310func TestStringBytes(t *testing.T) {311	// Test that encodeState.stringBytes and encodeState.string use the same encoding.312	es := &encodeState{}313	var r []rune314	for i := '\u0000'; i <= unicode.MaxRune; i++ {315		r = append(r, i)316	}317	s := string(r) + "\xff\xff\xffhello" // some invalid UTF-8 too318	_, err := es.string(s)319	if err != nil {320		t.Fatal(err)321	}322	esBytes := &encodeState{}323	_, err = esBytes.stringBytes([]byte(s))324	if err != nil {325		t.Fatal(err)326	}327	enc := es.Buffer.String()328	encBytes := esBytes.Buffer.String()329	if enc != encBytes {330		i := 0331		for i < len(enc) && i < len(encBytes) && enc[i] == encBytes[i] {332			i++333		}334		enc = enc[i:]335		encBytes = encBytes[i:]336		i = 0337		for i < len(enc) && i < len(encBytes) && enc[len(enc)-i-1] == encBytes[len(encBytes)-i-1] {338			i++339		}340		enc = enc[:len(enc)-i]341		encBytes = encBytes[:len(encBytes)-i]342		if len(enc) > 20 {343			enc = enc[:20] + "..."344		}345		if len(encBytes) > 20 {346			encBytes = encBytes[:20] + "..."347		}348		t.Errorf("encodings differ at %#q vs %#q", enc, encBytes)349	}350}351func TestIssue6458(t *testing.T) {352	type Foo struct {353		M RawMessage354	}355	x := Foo{RawMessage(`"foo"`)}356	b, err := Marshal(&x)357	if err != nil {358		t.Fatal(err)359	}360	if want := `{"M":"foo"}`; string(b) != want {361		t.Errorf("Marshal(&x) = %#q; want %#q", b, want)362	}...

1import (2func main() {3	r := gin.Default()4	r.POST("/post", func(c *gin.Context) {5		value, _ := ioutil.ReadAll(body)6		fmt.Println(string(value))7		c.String(200, "success")8	})9	r.Run(":8080")10}11import (12type Post struct {13}14func main() {15	r := gin.Default()16	r.POST("/post", func(c *gin.Context) {17		if err := c.ShouldBindBodyWith(&post, binding.JSON); err == nil {18			fmt.Println(post.Id)19			fmt.Println(post.Name)20			c.String(200, "success")21		} else {22			c.String(500, "error")23		}24	})25	r.Run(":8080")26}27import (28type Post struct {29}30func main() {31	r := gin.Default()32	r.POST("/post", func(c *gin.Context) {33		if err := c.ShouldBindJSON(&post); err == nil {34			fmt.Println(post.Id)35			fmt.Println(post.Name)36			c.String(200, "success")37		} else {38			c.String(500, "error")39		}40	})41	r.Run(":8080")42}43import (44type Post struct {45}46func main() {47	r := gin.Default()48	r.POST("/post", func(c *gin.Context) {49		if err := c.ShouldBindXML(&post); err == nil {50			fmt.Println(post.Id)51			fmt.Println(post.Name)52			c.String(200, "success")53		} else {

1import (2func main() {3    i, err := strconv.Atoi(s)4    if err != nil {5        fmt.Println(err)6    }7    fmt.Println(i)8}9import (10func main() {11    i, err := strconv.Atoi(s)12    if err != nil {13        fmt.Println(err)14    }15    fmt.Println(i)16}17import (18func main() {19    i, err := strconv.Atoi(s)20    if err != nil {21        fmt.Println(err)22    }23    fmt.Println(i)24}25import (26func main() {27    i, err := strconv.Atoi(s)28    if err != nil {29        fmt.Println(err)30    }31    fmt.Println(i)32}33import (34func main() {35    i, err := strconv.Atoi(s)36    if err != nil {37        fmt.Println(err)38    }39    fmt.Println(i)40}41import (42func main() {43    i, err := strconv.Atoi(s)44    if err != nil {45        fmt.Println(err)46    }47    fmt.Println(i)48}49import (50func main() {51    i, err := strconv.Atoi(s)52    if err != nil {53        fmt.Println(err)54    }55    fmt.Println(i)56}57import (

1func main() {2    got = Got{[]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}}3    fmt.Printf("%v4", got.Bytes())5}6func main() {7    got = Got{[9]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}}8    fmt.Printf("%v9", got.Bytes())10}

1import (2func main() {3parser := argparse.NewParser("1", "bytes")4num := parser.Int("n", "num", &argparse.Options{Required: true, Help: "num of bytes"})5err := parser.Parse(os.Args)6if err != nil {7fmt.Print(parser.Usage(err))8}9fmt.Println(num)10}11import (12func main() {13parser := argparse.NewParser("2", "bytes")14num := parser.Int("n", "num", &argparse.Options{Required: true, Help: "num of bytes"})15err := parser.Parse(os.Args)16if err != nil {17fmt.Print(parser.Usage(err))18}19fmt.Println(num)20}21import (22func main() {23parser := argparse.NewParser("3", "bytes")24num := parser.Int("n", "num", &argparse.Options{Required: true, Help: "num of bytes"})25err := parser.Parse(os.Args)26if err != nil {27fmt.Print(parser.Usage(err))28}29fmt.Println(num)30}31import (32func main() {33parser := argparse.NewParser("4", "bytes")34num := parser.Int("n", "num", &argparse.Options{Required: true, Help: "num of bytes"})35err := parser.Parse(os.Args)36if err != nil {37fmt.Print(parser.Usage(err))38}39fmt.Println(num)40}41import (42func main() {43parser := argparse.NewParser("5", "bytes")44num := parser.Int("n", "num", &argparse.Options{Required: true, Help: "num of bytes"})45err := parser.Parse(os.Args)46if err != nil {47fmt.Print(parser.Usage(err))48}49fmt.Println(num)50}

1import (2func main() {3	fmt.Println(got.Bytes("Hello"))4}5import (6func main() {7	fmt.Println(got.string([]byte("Hello")))8}9import (10func main() {11	fmt.Println(got.string(100))12}13import (14func main() {15	fmt.Println(got.Int("100"))16}17import (18func main() {19	fmt.Println(got.Float("100"))20}