diff --git a/ethcore/light/src/on_demand/request.rs b/ethcore/light/src/on_demand/request.rs index 614a9887c..ea90fa97b 100644 --- a/ethcore/light/src/on_demand/request.rs +++ b/ethcore/light/src/on_demand/request.rs @@ -900,7 +900,7 @@ mod tests { fn check_header_by_hash() { let mut header = Header::new(); header.set_number(10_000); - header.set_extra_data(b"test_header".into_vec()); + header.set_extra_data(b"test_header".to_vec()); let hash = header.hash(); let raw_header = encoded::Header::new(::rlp::encode(&header).into_vec()); @@ -953,7 +953,7 @@ mod tests { let mut db = MemoryDB::new(); let mut header = Header::new(); header.set_number(123_456); - header.set_extra_data(b"test_header".into_vec()); + header.set_extra_data(b"test_header".to_vec()); let addr = Address::random(); let rand_acc = || { diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs index 90a2bf50d..c0294c364 100644 --- a/ethcore/src/block.rs +++ b/ethcore/src/block.rs @@ -746,9 +746,9 @@ mod tests { let last_hashes = Arc::new(vec![genesis_header.hash()]); let mut open_block = OpenBlock::new(engine, Default::default(), false, db, &genesis_header, last_hashes.clone(), Address::zero(), (3141562.into(), 31415620.into()), vec![], false).unwrap(); let mut uncle1_header = Header::new(); - uncle1_header.set_extra_data(b"uncle1".into_vec()); + uncle1_header.set_extra_data(b"uncle1".to_vec()); let mut uncle2_header = Header::new(); - uncle2_header.set_extra_data(b"uncle2".into_vec()); + uncle2_header.set_extra_data(b"uncle2".to_vec()); open_block.push_uncle(uncle1_header).unwrap(); open_block.push_uncle(uncle2_header).unwrap(); let b = open_block.close_and_lock().seal(engine, vec![]).unwrap(); diff --git a/ethcore/src/engines/tendermint/mod.rs b/ethcore/src/engines/tendermint/mod.rs index 49d179b38..70d4e0ced 100644 --- a/ethcore/src/engines/tendermint/mod.rs +++ b/ethcore/src/engines/tendermint/mod.rs @@ -698,7 +698,7 @@ mod tests { vec![ ::rlp::encode(&view).into_vec(), ::rlp::encode(&H520::from(signature)).into_vec(), - ::rlp::EMPTY_LIST_RLP.into_vec() + ::rlp::EMPTY_LIST_RLP.to_vec() ] } @@ -812,7 +812,7 @@ mod tests { let vote_info = message_info_rlp(&VoteStep::new(2, 0, Step::Precommit), Some(header.bare_hash())); let signature1 = tap.sign(proposer, None, vote_info.sha3()).unwrap(); - seal[1] = ::rlp::NULL_RLP.into_vec(); + seal[1] = ::rlp::NULL_RLP.to_vec(); seal[2] = ::rlp::encode_list(&vec![H520::from(signature1.clone())]).into_vec(); header.set_seal(seal.clone()); diff --git a/ethcore/src/engines/vote_collector.rs b/ethcore/src/engines/vote_collector.rs index 84bbd2baf..d01d07f15 100644 --- a/ethcore/src/engines/vote_collector.rs +++ b/ethcore/src/engines/vote_collector.rs @@ -185,7 +185,7 @@ impl VoteCollector { guard .iter() .take_while(|&(r, _)| r <= round) - .map(|(_, c)| c.messages.iter().filter(|m| m.is_broadcastable()).map(|m| ::rlp::encode(m).into_vec()).collect::>()) + .map(|(_, c)| c.messages.iter().filter(|m| m.is_broadcastable()).map(|m| ::rlp::encode(m).to_vec()).collect::>()) .fold(Vec::new(), |mut acc, mut messages| { acc.append(&mut messages); acc }) } @@ -279,7 +279,7 @@ mod tests { // Wrong round, same signature. random_vote(&collector, signatures[1].clone(), 7, bh.clone()); - assert_eq!(signatures[0..1].into_vec(), collector.round_signatures(&propose_round, &bh.unwrap())); + assert_eq!(signatures[0..1].to_vec(), collector.round_signatures(&propose_round, &bh.unwrap())); assert_eq!(signatures[1..3].iter().collect::>(), collector.round_signatures(&commit_round, &bh.unwrap()).iter().collect::>()); } diff --git a/ethcore/src/evm/tests.rs b/ethcore/src/evm/tests.rs index 0f74428c2..7f3cf0e1c 100644 --- a/ethcore/src/evm/tests.rs +++ b/ethcore/src/evm/tests.rs @@ -123,7 +123,7 @@ impl Ext for FakeExt { sender_address: None, receive_address: None, value: Some(*value), - data: code.into_vec(), + data: code.to_vec(), code_address: None }); ContractCreateResult::Failed @@ -146,7 +146,7 @@ impl Ext for FakeExt { sender_address: Some(sender_address.clone()), receive_address: Some(receive_address.clone()), value: value, - data: data.into_vec(), + data: data.to_vec(), code_address: Some(code_address.clone()) }); MessageCallResult::Success(*gas, ReturnData::empty()) @@ -163,7 +163,7 @@ impl Ext for FakeExt { fn log(&mut self, topics: Vec, data: &[u8]) -> evm::Result<()> { self.logs.push(FakeLogEntry { topics: topics, - data: data.into_vec() + data: data.to_vec() }); Ok(()) } @@ -463,7 +463,7 @@ fn test_blockhash_eip210(factory: super::Factory) { value: ActionValue::Transfer(0.into()), code: Some(blockhash_contract_code.clone()), code_hash: blockhash_contract_code_hash, - data: Some(H256::from(i - 1).into_vec()), + data: Some(H256::from(i - 1).to_vec()), call_type: CallType::Call, }; let mut ex = Executive::new(&mut state, &env_info, &engine); diff --git a/ethcore/src/json_tests/executive.rs b/ethcore/src/json_tests/executive.rs index 0d2756a7d..7e37818f2 100644 --- a/ethcore/src/json_tests/executive.rs +++ b/ethcore/src/json_tests/executive.rs @@ -118,7 +118,7 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for TestExt<'a, T, V, B, E> fn create(&mut self, gas: &U256, value: &U256, code: &[u8], address: CreateContractAddress) -> ContractCreateResult { self.callcreates.push(CallCreate { - data: code.into_vec(), + data: code.to_vec(), destination: None, gas_limit: *gas, value: *value @@ -138,7 +138,7 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for TestExt<'a, T, V, B, E> _call_type: CallType ) -> MessageCallResult { self.callcreates.push(CallCreate { - data: data.into_vec(), + data: data.to_vec(), destination: Some(receive_address.clone()), gas_limit: *gas, value: value.unwrap() diff --git a/ethcore/src/snapshot/account.rs b/ethcore/src/snapshot/account.rs index a7b86ab77..a9f2ba593 100644 --- a/ethcore/src/snapshot/account.rs +++ b/ethcore/src/snapshot/account.rs @@ -339,7 +339,7 @@ mod tests { assert_eq!(acc, account2); let (acc, maybe_code) = from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr1), fat_rlp1, H256::zero()).unwrap(); - assert_eq!(maybe_code, Some(b"this is definitely code".into_vec())); + assert_eq!(maybe_code, Some(b"this is definitely code".to_vec())); assert_eq!(acc, account1); } diff --git a/ethcore/src/snapshot/block.rs b/ethcore/src/snapshot/block.rs index 8fe23e31e..75aa8e13e 100644 --- a/ethcore/src/snapshot/block.rs +++ b/ethcore/src/snapshot/block.rs @@ -173,7 +173,7 @@ mod tests { gas_price: U256::from(3000), gas: U256::from(50_000), value: U256::from(1), - data: b"Hello!".into_vec() + data: b"Hello!".to_vec() }.fake_sign(Address::from(0x69)); let t2 = Transaction { diff --git a/ethcore/src/state/mod.rs b/ethcore/src/state/mod.rs index 2f51d4d0e..a2480e3c3 100644 --- a/ethcore/src/state/mod.rs +++ b/ethcore/src/state/mod.rs @@ -1826,14 +1826,14 @@ mod tests { let mut state = get_temp_state(); state.require_or_from(&a, false, ||Account::new_contract(42.into(), 0.into()), |_|{}).unwrap(); state.init_code(&a, vec![1, 2, 3]).unwrap(); - assert_eq!(state.code(&a).unwrap(), Some(Arc::new([1u8, 2, 3].into_vec()))); + assert_eq!(state.code(&a).unwrap(), Some(Arc::new(vec![1u8, 2, 3]))); state.commit().unwrap(); - assert_eq!(state.code(&a).unwrap(), Some(Arc::new([1u8, 2, 3].into_vec()))); + assert_eq!(state.code(&a).unwrap(), Some(Arc::new(vec![1u8, 2, 3]))); state.drop() }; let state = State::from_existing(db, root, U256::from(0u8), Default::default()).unwrap(); - assert_eq!(state.code(&a).unwrap(), Some(Arc::new([1u8, 2, 3].into_vec()))); + assert_eq!(state.code(&a).unwrap(), Some(Arc::new(vec![1u8, 2, 3]))); } #[test] @@ -2040,7 +2040,7 @@ mod tests { let mut state = get_temp_state(); let a: Address = 0xa.into(); - state.init_code(&a, b"abcdefg".into_vec()).unwrap();; + state.init_code(&a, b"abcdefg".to_vec()).unwrap();; state.add_balance(&a, &256.into(), CleanupMode::NoEmpty).unwrap(); state.set_storage(&a, 0xb.into(), 0xc.into()).unwrap(); diff --git a/ethcore/src/types/transaction.rs b/ethcore/src/types/transaction.rs index 882c854a0..016928a09 100644 --- a/ethcore/src/types/transaction.rs +++ b/ethcore/src/types/transaction.rs @@ -570,7 +570,7 @@ fn signing() { gas_price: U256::from(3000), gas: U256::from(50_000), value: U256::from(1), - data: b"Hello!".into_vec() + data: b"Hello!".to_vec() }.sign(&key.secret(), None); assert_eq!(Address::from(key.public().sha3()), t.sender()); assert_eq!(t.network_id(), None); @@ -584,7 +584,7 @@ fn fake_signing() { gas_price: U256::from(3000), gas: U256::from(50_000), value: U256::from(1), - data: b"Hello!".into_vec() + data: b"Hello!".to_vec() }.fake_sign(Address::from(0x69)); assert_eq!(Address::from(0x69), t.sender()); assert_eq!(t.network_id(), None); @@ -604,7 +604,7 @@ fn should_recover_from_network_specific_signing() { gas_price: U256::from(3000), gas: U256::from(50_000), value: U256::from(1), - data: b"Hello!".into_vec() + data: b"Hello!".to_vec() }.sign(&key.secret(), Some(69)); assert_eq!(Address::from(key.public().sha3()), t.sender()); assert_eq!(t.network_id(), Some(69)); diff --git a/ethcore/src/verification/verification.rs b/ethcore/src/verification/verification.rs index 024f8ced4..d244c2af1 100644 --- a/ethcore/src/verification/verification.rs +++ b/ethcore/src/verification/verification.rs @@ -338,7 +338,7 @@ mod tests { fn block_header_data(&self, hash: &H256) -> Option { self.block(hash) - .map(|b| b.header_view().rlp().as_raw().into_vec()) + .map(|b| b.header_view().rlp().as_raw().to_vec()) .map(encoded::Header::new) } diff --git a/ethkey/src/extended.rs b/ethkey/src/extended.rs index e3e5e5459..45ed0547f 100644 --- a/ethkey/src/extended.rs +++ b/ethkey/src/extended.rs @@ -394,7 +394,7 @@ mod tests { fn master_chain_basic() -> (H256, H256) { let seed = H128::from_str("000102030405060708090a0b0c0d0e0f") .expect("Seed should be valid H128") - .into_vec(); + .to_vec(); derivation::seed_pair(&*seed) } @@ -475,7 +475,7 @@ mod tests { fn test_seeds() { let seed = H128::from_str("000102030405060708090a0b0c0d0e0f") .expect("Seed should be valid H128") - .into_vec(); + .to_vec(); /// private key from bitcoin test vector /// xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs diff --git a/ipc/nano/src/lib.rs b/ipc/nano/src/lib.rs index 06abccad1..9be3d2b1d 100644 --- a/ipc/nano/src/lib.rs +++ b/ipc/nano/src/lib.rs @@ -284,7 +284,7 @@ mod service_tests { self.methods_stack.write().unwrap().push( TestInvoke { method_num: method_num, - params: buf.into_vec(), + params: buf.to_vec(), }); vec![] } diff --git a/rpc/src/v1/helpers/fake_sign.rs b/rpc/src/v1/helpers/fake_sign.rs index 5e50c4701..21cb0cfe1 100644 --- a/rpc/src/v1/helpers/fake_sign.rs +++ b/rpc/src/v1/helpers/fake_sign.rs @@ -36,6 +36,6 @@ pub fn sign_call( gas: request.gas.unwrap_or(50_000_000.into()), gas_price: request.gas_price.unwrap_or_else(|| default_gas_price(&**client, &**miner)), value: request.value.unwrap_or(0.into()), - data: request.data.unwrap_or(Vec::new()) + data: request.data.unwrap_or_default(), }.fake_sign(from)) } diff --git a/rpc/src/v1/helpers/light_fetch.rs b/rpc/src/v1/helpers/light_fetch.rs index ab9207113..a0316f9cb 100644 --- a/rpc/src/v1/helpers/light_fetch.rs +++ b/rpc/src/v1/helpers/light_fetch.rs @@ -192,7 +192,7 @@ impl LightFetch { let action = req.to.map_or(Action::Create, Action::Call); let gas = req.gas.unwrap_or(U256::from(10_000_000)); // better gas amount? let value = req.value.unwrap_or_else(U256::zero); - let data = req.data.unwrap_or(Vec::new()); + let data = req.data.unwrap_or_default(); future::done(match nonce { Some(n) => Ok(EthTransaction { diff --git a/rpc/src/v1/tests/mocked/signer.rs b/rpc/src/v1/tests/mocked/signer.rs index fb8b8a0c1..f92486d16 100644 --- a/rpc/src/v1/tests/mocked/signer.rs +++ b/rpc/src/v1/tests/mocked/signer.rs @@ -518,7 +518,7 @@ fn should_confirm_decrypt_with_phrase() { ), Origin::Unknown).unwrap(); assert_eq!(tester.signer.requests().len(), 1); - let decrypted = serde_json::to_string(&RpcBytes::new(b"phrase".into_vec())).unwrap(); + let decrypted = serde_json::to_string(&RpcBytes::new(b"phrase".to_vec())).unwrap(); // when let request = r#"{ diff --git a/sync/src/blocks.rs b/sync/src/blocks.rs index 13d71b766..3dcc912a7 100644 --- a/sync/src/blocks.rs +++ b/sync/src/blocks.rs @@ -524,7 +524,7 @@ mod test { let blocks: Vec<_> = (0..nblocks) .map(|i| (&client as &BlockChainClient).block(BlockId::Number(i as BlockNumber)).unwrap().into_inner()) .collect(); - let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().into_vec()).collect(); + let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().to_vec()).collect(); let hashes: Vec<_> = headers.iter().map(|h| HeaderView::new(h).sha3()).collect(); let heads: Vec<_> = hashes.iter().enumerate().filter_map(|(i, h)| if i % 20 == 0 { Some(h.clone()) } else { None }).collect(); bc.reset_to(heads); @@ -541,7 +541,7 @@ mod test { assert_eq!(bc.downloading_headers.len(), 1); assert!(bc.drain().is_empty()); - bc.insert_headers(headers[0..6].into_vec()); + bc.insert_headers(headers[0..6].to_vec()); assert_eq!(hashes[5], bc.heads[0]); for h in &hashes[0..6] { bc.clear_header_download(h) @@ -558,13 +558,13 @@ mod test { assert_eq!(hashes[5], h); let (h, _) = bc.needed_headers(6, false).unwrap(); assert_eq!(hashes[20], h); - bc.insert_headers(headers[10..16].into_vec()); + bc.insert_headers(headers[10..16].to_vec()); assert!(bc.drain().is_empty()); - bc.insert_headers(headers[5..10].into_vec()); + bc.insert_headers(headers[5..10].to_vec()); assert_eq!(&bc.drain().into_iter().map(|b| b.block).collect::>()[..], &blocks[6..16]); assert_eq!(hashes[15], bc.heads[0]); - bc.insert_headers(headers[15..].into_vec()); + bc.insert_headers(headers[15..].to_vec()); bc.drain(); assert!(bc.is_empty()); } @@ -579,16 +579,16 @@ mod test { let blocks: Vec<_> = (0..nblocks) .map(|i| (&client as &BlockChainClient).block(BlockId::Number(i as BlockNumber)).unwrap().into_inner()) .collect(); - let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().into_vec()).collect(); + let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().to_vec()).collect(); let hashes: Vec<_> = headers.iter().map(|h| HeaderView::new(h).sha3()).collect(); let heads: Vec<_> = hashes.iter().enumerate().filter_map(|(i, h)| if i % 20 == 0 { Some(h.clone()) } else { None }).collect(); bc.reset_to(heads); - bc.insert_headers(headers[2..22].into_vec()); + bc.insert_headers(headers[2..22].to_vec()); assert_eq!(hashes[0], bc.heads[0]); assert_eq!(hashes[21], bc.heads[1]); assert!(bc.head.is_none()); - bc.insert_headers(headers[0..2].into_vec()); + bc.insert_headers(headers[0..2].to_vec()); assert!(bc.head.is_some()); assert_eq!(hashes[21], bc.heads[0]); } @@ -603,14 +603,14 @@ mod test { let blocks: Vec<_> = (0..nblocks) .map(|i| (&client as &BlockChainClient).block(BlockId::Number(i as BlockNumber)).unwrap().into_inner()) .collect(); - let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().into_vec()).collect(); + let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().to_vec()).collect(); let hashes: Vec<_> = headers.iter().map(|h| HeaderView::new(h).sha3()).collect(); let heads: Vec<_> = hashes.iter().enumerate().filter_map(|(i, h)| if i % 20 == 0 { Some(h.clone()) } else { None }).collect(); bc.reset_to(heads); - bc.insert_headers(headers[1..2].into_vec()); + bc.insert_headers(headers[1..2].to_vec()); assert!(bc.drain().is_empty()); - bc.insert_headers(headers[0..1].into_vec()); + bc.insert_headers(headers[0..1].to_vec()); assert_eq!(bc.drain().len(), 2); } } diff --git a/sync/src/chain.rs b/sync/src/chain.rs index ede8f515e..badd784a4 100644 --- a/sync/src/chain.rs +++ b/sync/src/chain.rs @@ -2361,14 +2361,14 @@ mod tests { rlp.out() } fn to_header_vec(rlp: ::chain::RlpResponseResult) -> Vec { - Rlp::new(&rlp.unwrap().unwrap().1.out()).iter().map(|r| r.as_raw().into_vec()).collect() + Rlp::new(&rlp.unwrap().unwrap().1.out()).iter().map(|r| r.as_raw().to_vec()).collect() } let mut client = TestBlockChainClient::new(); client.add_blocks(100, EachBlockWith::Nothing); let blocks: Vec<_> = (0 .. 100) .map(|i| (&client as &BlockChainClient).block(BlockId::Number(i as BlockNumber)).map(|b| b.into_inner()).unwrap()).collect(); - let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().into_vec()).collect(); + let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).as_raw().to_vec()).collect(); let hashes: Vec<_> = headers.iter().map(|h| HeaderView::new(h).sha3()).collect(); let queue = RwLock::new(VecDeque::new()); diff --git a/sync/src/snapshot.rs b/sync/src/snapshot.rs index bef053f41..cecfbe425 100644 --- a/sync/src/snapshot.rs +++ b/sync/src/snapshot.rs @@ -149,8 +149,8 @@ mod test { } fn test_manifest() -> (ManifestData, H256, Vec, Vec) { - let state_chunks: Vec = (0..20).map(|_| H256::random().into_vec()).collect(); - let block_chunks: Vec = (0..20).map(|_| H256::random().into_vec()).collect(); + let state_chunks: Vec = (0..20).map(|_| H256::random().to_vec()).collect(); + let block_chunks: Vec = (0..20).map(|_| H256::random().to_vec()).collect(); let manifest = ManifestData { version: 2, state_hashes: state_chunks.iter().map(|data| data.sha3()).collect(), @@ -180,7 +180,7 @@ mod test { let (manifest, mhash, state_chunks, block_chunks) = test_manifest(); snapshot.reset_to(&manifest, &mhash); assert_eq!(snapshot.done_chunks(), 0); - assert!(snapshot.validate_chunk(&H256::random().into_vec()).is_err()); + assert!(snapshot.validate_chunk(&H256::random().to_vec()).is_err()); let requested: Vec = (0..40).map(|_| snapshot.needed_chunk().unwrap()).collect(); assert!(snapshot.needed_chunk().is_none()); diff --git a/sync/src/tests/chain.rs b/sync/src/tests/chain.rs index 6366a63c2..23ed4b7ea 100644 --- a/sync/src/tests/chain.rs +++ b/sync/src/tests/chain.rs @@ -102,7 +102,7 @@ fn forked_with_misbehaving_peer() { let mut net = TestNet::new(3); let mut alt_spec = ::ethcore::spec::Spec::new_test(); - alt_spec.extra_data = b"fork".into_vec(); + alt_spec.extra_data = b"fork".to_vec(); // peer 0 is on a totally different chain with higher total difficulty net.peer_mut(0).chain = Arc::new(TestBlockChainClient::new_with_spec(alt_spec)); net.peer(0).chain.add_blocks(50, EachBlockWith::Nothing); diff --git a/sync/src/tests/snapshot.rs b/sync/src/tests/snapshot.rs index b9d56066f..995d7a056 100644 --- a/sync/src/tests/snapshot.rs +++ b/sync/src/tests/snapshot.rs @@ -44,8 +44,8 @@ impl TestSnapshotService { pub fn new_with_snapshot(num_chunks: usize, block_hash: H256, block_number: BlockNumber) -> TestSnapshotService { let num_state_chunks = num_chunks / 2; let num_block_chunks = num_chunks - num_state_chunks; - let state_chunks: Vec = (0..num_state_chunks).map(|_| H256::random().into_vec()).collect(); - let block_chunks: Vec = (0..num_block_chunks).map(|_| H256::random().into_vec()).collect(); + let state_chunks: Vec = (0..num_state_chunks).map(|_| H256::random().to_vec()).collect(); + let block_chunks: Vec = (0..num_block_chunks).map(|_| H256::random().to_vec()).collect(); let manifest = ManifestData { version: 2, state_hashes: state_chunks.iter().map(|data| data.sha3()).collect(), diff --git a/util/src/trie/triedb.rs b/util/src/trie/triedb.rs index aeadb72a4..5da304167 100644 --- a/util/src/trie/triedb.rs +++ b/util/src/trie/triedb.rs @@ -401,7 +401,7 @@ fn iterator_seek() { let t = TrieDB::new(&memdb, &root).unwrap(); let mut iter = t.iter().unwrap(); - assert_eq!(iter.next(), Some(Ok((b"A".into_vec(), DBValue::from_slice(b"A"))))); + assert_eq!(iter.next(), Some(Ok((b"A".to_vec(), DBValue::from_slice(b"A"))))); iter.seek(b"!").unwrap(); assert_eq!(d, iter.map(|x| x.unwrap().1).collect::>()); let mut iter = t.iter().unwrap(); diff --git a/util/src/trie/triedbmut.rs b/util/src/trie/triedbmut.rs index eec9b999a..6c770a9d5 100644 --- a/util/src/trie/triedbmut.rs +++ b/util/src/trie/triedbmut.rs @@ -966,7 +966,7 @@ mod tests { debug!("{:?} of 10000 stress tests done", test_i); } let x = StandardMap { - alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".into_vec()), + alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".to_vec()), min_key: 5, journal_key: 0, value_mode: ValueMode::Index, @@ -1026,14 +1026,14 @@ mod tests { let mut memdb = MemoryDB::new(); let mut root = H256::new(); let mut t1 = TrieDBMut::new(&mut memdb, &mut root); - t1.insert(&[0x01, 0x23], &big_value.into_vec()).unwrap(); - t1.insert(&[0x01, 0x34], &big_value.into_vec()).unwrap(); + t1.insert(&[0x01, 0x23], big_value).unwrap(); + t1.insert(&[0x01, 0x34], big_value).unwrap(); let mut memdb2 = MemoryDB::new(); let mut root2 = H256::new(); let mut t2 = TrieDBMut::new(&mut memdb2, &mut root2); - t2.insert(&[0x01], &big_value.into_vec()).unwrap(); - t2.insert(&[0x01, 0x23], &big_value.into_vec()).unwrap(); - t2.insert(&[0x01, 0x34], &big_value.into_vec()).unwrap(); + t2.insert(&[0x01], big_value).unwrap(); + t2.insert(&[0x01, 0x23], big_value).unwrap(); + t2.insert(&[0x01, 0x34], big_value).unwrap(); t2.remove(&[0x01]).unwrap(); } @@ -1127,8 +1127,8 @@ mod tests { t.insert(&[0x01u8, 0x23], big_value0).unwrap(); t.insert(&[0x11u8, 0x23], big_value1).unwrap(); assert_eq!(*t.root(), trie_root(vec![ - (vec![0x01u8, 0x23], big_value0.into_vec()), - (vec![0x11u8, 0x23], big_value1.into_vec()) + (vec![0x01u8, 0x23], big_value0.to_vec()), + (vec![0x11u8, 0x23], big_value1.to_vec()) ])); } @@ -1142,8 +1142,8 @@ mod tests { t.insert(&[0x01u8, 0x23], big_value).unwrap(); t.insert(&[0x11u8, 0x23], big_value).unwrap(); assert_eq!(*t.root(), trie_root(vec![ - (vec![0x01u8, 0x23], big_value.into_vec()), - (vec![0x11u8, 0x23], big_value.into_vec()) + (vec![0x01u8, 0x23], big_value.to_vec()), + (vec![0x11u8, 0x23], big_value.to_vec()) ])); } @@ -1190,7 +1190,7 @@ mod tests { let mut seed = H256::new(); for _ in 0..50 { let x = StandardMap { - alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".into_vec()), + alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".to_vec()), min_key: 5, journal_key: 0, value_mode: ValueMode::Index, @@ -1241,7 +1241,7 @@ mod tests { fn insert_empty() { let mut seed = H256::new(); let x = StandardMap { - alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".into_vec()), + alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".to_vec()), min_key: 5, journal_key: 0, value_mode: ValueMode::Index, @@ -1269,7 +1269,7 @@ mod tests { fn return_old_values() { let mut seed = H256::new(); let x = StandardMap { - alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".into_vec()), + alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".to_vec()), min_key: 5, journal_key: 0, value_mode: ValueMode::Index, diff --git a/util/src/triehash.rs b/util/src/triehash.rs index 4a68e5586..ca1974e7b 100644 --- a/util/src/triehash.rs +++ b/util/src/triehash.rs @@ -331,7 +331,7 @@ mod tests { #[test] fn simple_test() { assert_eq!(trie_root(vec![ - (b"A".into_vec(), b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".into_vec()) + (b"A".to_vec(), b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_vec()) ]), H256::from_str("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab").unwrap()); }