uint to separated crate

Cargo.lock

@@ -44,6 +44,18 @@ dependencies = [
  "syntex_syntax 0.29.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "bigint"
+version = "0.1.0"
+dependencies = [
+ "arrayvec 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "heapsize 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "bitflags"
 version = "0.3.3"
@@ -220,6 +232,7 @@ name = "ethcore-util"
 version = "0.9.99"
 dependencies = [
  "arrayvec 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bigint 0.1.0",
  "clippy 0.0.44 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "elastic-array 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",

ethcore/src/action_params.rs

@@ -15,9 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Evm input params.
-use util::hash::*;
-use util::uint::*;
-use util::bytes::*;
+use common::*;
 
 /// Transaction value
 #[derive(Clone, Debug)]

ethcore/src/blockchain/best_block.rs

@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
-use util::uint::U256;
+use util::common::{U256,H256};
 use header::BlockNumber;
 
 /// Best block info.

ethcore/src/blockchain/block_info.rs

@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
-use util::uint::U256;
+use util::common::{U256,H256};
 use header::BlockNumber;
 
 /// Brief info about inserted block.

ethcore/src/blockchain/bloom_indexer.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
+use util::common::H256;
 use chainfilter::BloomIndex;
 
 /// Represents location of block bloom in extras database.
@@ -44,7 +44,7 @@ impl BloomIndexer {
 	/// Calculates bloom's position in database.
 	pub fn location(&self, bloom_index: &BloomIndex) -> BlocksBloomLocation {
 		use std::{mem, ptr};
-		
+
 		let hash = unsafe {
 			let mut hash: H256 = mem::zeroed();
 			ptr::copy(&[bloom_index.index / self.index_size] as *const usize as *const u8, hash.as_mut_ptr(), 8);

ethcore/src/blockchain/tree_route.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
+use util::common::H256;
 
 /// Represents a tree route between `from` block and `to` block:
 #[derive(Debug)]

ethcore/src/blockchain/update.rs

@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use util::hash::H256;
+use util::common::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
 use extras::{BlockDetails, BlockReceipts, TransactionAddress, BlocksBlooms};

ethcore/src/evm/ext.rs

@@ -16,9 +16,7 @@
 
 //! Interface for Evm externalities.
 
-use common::Bytes;
-use util::hash::*;
-use util::uint::*;
+use util::common::*;
 use evm::{Schedule, Error};
 use env_info::*;
 
@@ -60,22 +58,22 @@ pub trait Ext {
 	fn blockhash(&self, number: &U256) -> H256;
 
 	/// Creates new contract.
-	/// 
+	///
 	/// Returns gas_left and contract address if contract creation was succesfull.
 	fn create(&mut self, gas: &U256, value: &U256, code: &[u8]) -> ContractCreateResult;
 
 	/// Message call.
-	/// 
+	///
 	/// Returns Err, if we run out of gas.
-	/// Otherwise returns call_result which contains gas left 
+	/// Otherwise returns call_result which contains gas left
 	/// and true if subcall was successfull.
-	fn call(&mut self, 
-			gas: &U256, 
-			sender_address: &Address, 
-			receive_address: &Address, 
+	fn call(&mut self,
+			gas: &U256,
+			sender_address: &Address,
+			receive_address: &Address,
 			value: Option<U256>,
-			data: &[u8], 
-			code_address: &Address, 
+			data: &[u8],
+			code_address: &Address,
 			output: &mut [u8]) -> MessageCallResult;
 
 	/// Returns code at given address
@@ -99,7 +97,7 @@ pub trait Ext {
 	fn env_info(&self) -> &EnvInfo;
 
 	/// Returns current depth of execution.
-	/// 
+	///
 	/// If contract A calls contract B, and contract B calls C,
 	/// then A depth is 0, B is 1, C is 2 and so on.
 	fn depth(&self) -> usize;

ethcore/src/state.rs

@@ -335,10 +335,9 @@ impl fmt::Debug for State {
 mod tests {
 
 use super::*;
-use util::hash::*;
+use util::common::*;
 use util::trie::*;
 use util::rlp::*;
-use util::uint::*;
 use account::*;
 use tests::helpers::*;
 use devtools::*;

rpc/src/v1/impls/eth.rs

@@ -18,8 +18,7 @@
 use std::sync::{Arc, Weak};
 use ethsync::{EthSync, SyncState};
 use jsonrpc_core::*;
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use util::sha3::*;
 use ethcore::client::*;
 use ethcore::views::*;

rpc/src/v1/types/block.rs

@@ -15,8 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use serde::{Serialize, Serializer};
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use v1::types::{Bytes, Transaction, OptionalValue};
 
 #[derive(Debug)]
@@ -71,8 +70,7 @@ pub struct Block {
 #[cfg(test)]
 mod tests {
 	use serde_json;
-	use util::hash::*;
-	use util::uint::*;
+	use util::numbers::*;
 	use v1::types::{Transaction, Bytes, OptionalValue};
 	use super::*;
 

rpc/src/v1/types/filter.rs

@@ -17,7 +17,7 @@
 use serde::{Deserialize, Deserializer, Error};
 use serde_json::value;
 use jsonrpc_core::Value;
-use util::hash::*;
+use util::numbers::*;
 use v1::types::BlockNumber;
 use ethcore::filter::Filter as EthFilter;
 use ethcore::client::BlockId;

rpc/src/v1/types/log.rs

@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use ethcore::log_entry::LocalizedLogEntry;
 use v1::types::Bytes;
 
@@ -55,8 +54,7 @@ impl From<LocalizedLogEntry> for Log {
 mod tests {
 	use serde_json;
 	use std::str::FromStr;
-	use util::hash::*;
-	use util::uint::*;
+	use util::numbers::*;
 	use v1::types::{Bytes, Log};
 
 	#[test]
@@ -66,7 +64,7 @@ mod tests {
 		let log = Log {
 			address: Address::from_str("33990122638b9132ca29c723bdf037f1a891a70c").unwrap(),
 			topics: vec![
-				H256::from_str("a6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc").unwrap(), 
+				H256::from_str("a6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc").unwrap(),
 				H256::from_str("4861736852656700000000000000000000000000000000000000000000000000").unwrap()
 			],
 			data: Bytes::new(vec![]),

rpc/src/v1/types/sync.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use serde::{Serialize, Serializer};
-use util::uint::*;
+use util::numbers::*;
 
 #[derive(Default, Debug, Serialize, PartialEq)]
 pub struct SyncInfo {

rpc/src/v1/types/transaction.rs

@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use ethcore::transaction::{LocalizedTransaction, Action};
 use v1::types::{Bytes, OptionalValue};
 

util/Cargo.toml

@@ -35,6 +35,7 @@ ethcore-devtools = { path = "../devtools" }
 libc = "0.2.7"
 vergen = "0.1"
 target_info = "0.1"
+bigint = { path = "bigint" }
 
 [features]
 default = []

util/bigint/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+description = "Rust-assembler implementation of big integers arithmetic"
+homepage = "http://ethcore.io"
+license = "GPL-3.0"
+name = "bigint"
+version = "0.1.0"
+authors = ["Ethcore <admin@ethcore.io>"]
+build = "build.rs"
+
+[build-dependencies]
+rustc_version = "0.1"
+
+[dependencies]
+rustc-serialize = "0.3"
+arrayvec = "0.3"
+rand = "0.3.12"
+serde = "0.7.0"
+clippy = { version = "0.0.44", optional = true }
+heapsize = "0.3"
+
+[features]
+x64asm_arithmetic=[]
+rust_arithmetic=[]

util/bigint/build.rs

@@ -0,0 +1,25 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+extern crate rustc_version;
+
+use rustc_version::{version_meta, Channel};
+
+fn main() {
+	if let Channel::Nightly = version_meta().channel {
+		println!("cargo:rustc-cfg=asm_available");
+	}
+}

util/bigint/src/lib.rs

@@ -0,0 +1,23 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg_attr(asm_available, feature(asm))]
+
+extern crate rustc_serialize;
+extern crate serde;
+#[macro_use] extern crate heapsize;
+
+pub mod uint;

util/bigint/src/uint.rs

@@ -36,10 +36,26 @@
 //! The functions here are designed to be fast.
 //!
 
-use standard::*;
-use from_json::*;
-use rustc_serialize::hex::ToHex;
+use std::fmt;
+use std::cmp;
+
+use std::mem;
+use std::ops;
+use std::slice;
+use std::result;
+use std::option;
+use std::str::{FromStr};
+use std::convert::From;
+use std::hash::{Hash, Hasher};
+use std::ops::*;
+use std::cmp::*;
+use std::collections::*;
+
 use serde;
+use rustc_serialize::json::Json;
+use rustc_serialize::base64::FromBase64;
+use rustc_serialize::hex::{FromHex, FromHexError, ToHex};
+
 
 macro_rules! impl_map_from {
 	($thing:ident, $from:ty, $to:ty) => {
@@ -51,7 +67,7 @@ macro_rules! impl_map_from {
 	}
 }
 
-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_add {
 	($name:ident, $n_words:expr, $self_expr: expr, $other: expr) => ({
 		uint_overflowing_add_reg!($name, $n_words, $self_expr, $other)
@@ -88,8 +104,7 @@ macro_rules! uint_overflowing_add_reg {
 	})
 }
 
-
-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_add {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@@ -165,7 +180,7 @@ macro_rules! uint_overflowing_add {
 	)
 }
 
-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_sub {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let res = overflowing!((!$other).overflowing_add(From::from(1u64)));
@@ -174,7 +189,7 @@ macro_rules! uint_overflowing_sub {
 	})
 }
 
-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_sub {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@@ -250,7 +265,7 @@ macro_rules! uint_overflowing_sub {
 	})
 }
 
-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_mul {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@@ -370,7 +385,7 @@ macro_rules! uint_overflowing_mul {
 	)
 }
 
-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_mul {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		uint_overflowing_mul_reg!($name, $n_words, $self_expr, $other)
@@ -381,7 +396,6 @@ macro_rules! uint_overflowing_mul_reg {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut res = $name::from(0u64);
 		let mut overflow = false;
-		// TODO: be more efficient about this
 		for i in 0..(2 * $n_words) {
 			let v = overflowing!($self_expr.overflowing_mul_u32(($other >> (32 * i)).low_u32()), overflow);
 			let res2 = overflowing!(v.overflowing_shl(32 * i as u32), overflow);
@@ -416,7 +430,7 @@ macro_rules! panic_on_overflow {
 }
 
 /// Large, fixed-length unsigned integer type.
-pub trait Uint: Sized + Default + FromStr + From<u64> + FromJson + fmt::Debug + fmt::Display + PartialOrd + Ord + PartialEq + Eq + Hash {
+pub trait Uint: Sized + Default + FromStr + From<u64> + fmt::Debug + fmt::Display + PartialOrd + Ord + PartialEq + Eq + Hash {
 
 	/// Returns new instance equalling zero.
 	fn zero() -> Self;
@@ -779,22 +793,6 @@ macro_rules! construct_uint {
 			}
 		}
 
-		impl FromJson for $name {
-			fn from_json(json: &Json) -> Self {
-				match *json {
-					Json::String(ref s) => {
-						if s.len() >= 2 && &s[0..2] == "0x" {
-							FromStr::from_str(&s[2..]).unwrap_or_else(|_| Default::default())
-						} else {
-							Uint::from_dec_str(s).unwrap_or_else(|_| Default::default())
-						}
-					},
-					Json::U64(u) => From::from(u),
-					Json::I64(i) => From::from(i as u64),
-					_ => Uint::zero(),
-				}
-			}
-		}
 
 		impl_map_from!($name, u8, u64);
 		impl_map_from!($name, u16, u64);
@@ -1100,7 +1098,7 @@ construct_uint!(U128, 2);
 impl U256 {
 	/// Multiplies two 256-bit integers to produce full 512-bit integer
 	/// No overflow possible
-	#[cfg(all(x64asm, target_arch="x86_64"))]
+	#[cfg(all(asm_available, target_arch="x86_64"))]
 	pub fn full_mul(self, other: U256) -> U512 {
 		let self_t: &[u64; 4] = unsafe { &mem::transmute(self) };
 		let other_t: &[u64; 4] = unsafe { &mem::transmute(other) };
@@ -1239,7 +1237,7 @@ impl U256 {
 
 	/// Multiplies two 256-bit integers to produce full 512-bit integer
 	/// No overflow possible
-	#[cfg(not(all(x64asm, target_arch="x86_64")))]
+	#[cfg(not(all(asm_available, target_arch="x86_64")))]
 	pub fn full_mul(self, other: U256) -> U512 {
 		let self_512 = U512::from(self);
 		let other_512 = U512::from(other);
@@ -1338,6 +1336,9 @@ pub const ZERO_U256: U256 = U256([0x00u64; 4]);
 /// Constant value of `U256::one()` that can be used for a reference saving an additional instance creation.
 pub const ONE_U256: U256 = U256([0x01u64, 0x00u64, 0x00u64, 0x00u64]);
 
+
+known_heap_size!(0, U128, U256);
+
 #[cfg(test)]
 mod tests {
 	use uint::{Uint, U128, U256, U512};

util/build.rs

@@ -1,13 +1,7 @@
 extern crate vergen;
-extern crate rustc_version;
 
 use vergen::*;
-use rustc_version::{version_meta, Channel};
 
 fn main() {
 	vergen(OutputFns::all()).unwrap();
-
-	if let Channel::Nightly = version_meta().channel {
-		println!("cargo:rustc-cfg=x64asm");
-	}
 }

util/src/common.rs

@@ -19,12 +19,12 @@
 pub use standard::*;
 pub use from_json::*;
 pub use error::*;
-pub use hash::*;
-pub use uint::*;
 pub use bytes::*;
 pub use vector::*;
+pub use numbers::*;
 pub use sha3::*;
 
+
 #[macro_export]
 macro_rules! map {
 	( $( $x:expr => $y:expr ),* ) => {

util/src/crypto.rs

@@ -16,9 +16,8 @@
 
 //! Ethcore crypto.
 
-use hash::*;
+use numbers::*;
 use bytes::*;
-use uint::*;
 use secp256k1::{key, Secp256k1};
 use rand::os::OsRng;
 
@@ -152,7 +151,7 @@ impl KeyPair {
 /// EC functions
 pub mod ec {
 	use hash::*;
-	use uint::*;
+	use bigint::uint::*;
 	use standard::*;
 	use crypto::*;
 	use crypto::{self};

util/src/from_json.rs

@@ -17,6 +17,7 @@
 //! Coversion from json.
 
 use standard::*;
+use bigint::uint::*;
 
 #[macro_export]
 macro_rules! xjson {
@@ -30,3 +31,20 @@ pub trait FromJson {
 	/// Convert a JSON value to an instance of this type.
 	fn from_json(json: &Json) -> Self;
 }
+
+impl FromJson for U256 {
+	fn from_json(json: &Json) -> Self {
+		match *json {
+			Json::String(ref s) => {
+				if s.len() >= 2 && &s[0..2] == "0x" {
+					FromStr::from_str(&s[2..]).unwrap_or_else(|_| Default::default())
+				} else {
+					Uint::from_dec_str(s).unwrap_or_else(|_| Default::default())
+				}
+			},
+			Json::U64(u) => From::from(u),
+			Json::I64(i) => From::from(i as u64),
+			_ => Uint::zero(),
+		}
+	}
+}

util/src/hash.rs

@@ -23,7 +23,7 @@ use rand::Rng;
 use rand::os::OsRng;
 use bytes::{BytesConvertable,Populatable};
 use from_json::*;
-use uint::{Uint, U256};
+use bigint::uint::{Uint, U256};
 use rustc_serialize::hex::ToHex;
 use serde;
 
@@ -595,7 +595,7 @@ pub fn h256_from_hex(s: &str) -> H256 {
 
 /// Convert `n` to an `H256`, setting the rightmost 8 bytes.
 pub fn h256_from_u64(n: u64) -> H256 {
-	use uint::U256;
+	use bigint::uint::U256;
 	H256::from(&U256::from(n))
 }
 
@@ -631,7 +631,7 @@ pub static ZERO_H256: H256 = H256([0x00; 32]);
 #[cfg(test)]
 mod tests {
 	use hash::*;
-	use uint::*;
+	use bigint::uint::*;
 	use std::str::FromStr;
 
 	#[test]

util/src/heapsizeof.rs

@@ -16,8 +16,7 @@
 
 //! Calculates heapsize of util types.
 
-use uint::*;
 use hash::*;
 
 known_heap_size!(0, H32, H64, H128, Address, H256, H264, H512, H520, H1024, H2048);
-known_heap_size!(0, U128, U256);
+

util/src/lib.rs

@@ -16,7 +16,6 @@
 
 #![warn(missing_docs)]
 #![cfg_attr(feature="dev", feature(plugin))]
-#![cfg_attr(x64asm, feature(asm))]
 #![cfg_attr(feature="dev", plugin(clippy))]
 
 // Clippy settings
@@ -111,15 +110,16 @@ extern crate libc;
 extern crate rustc_version;
 extern crate target_info;
 extern crate vergen;
+extern crate bigint;
 
 pub mod standard;
 #[macro_use]
 pub mod from_json;
 #[macro_use]
 pub mod common;
+pub mod numbers;
 pub mod error;
 pub mod hash;
-pub mod uint;
 pub mod bytes;
 pub mod rlp;
 pub mod misc;

util/src/numbers.rs

@@ -0,0 +1,20 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Utils number types.
+
+pub use hash::*;
+pub use bigint::uint::*;

util/src/rlp/bytes.rs

@@ -21,7 +21,7 @@ use std::mem;
 use std::fmt;
 use std::cmp::Ordering;
 use std::error::Error as StdError;
-use uint::{Uint, U128, U256};
+use bigint::uint::{Uint, U128, U256};
 use hash::FixedHash;
 use elastic_array::*;
 

util/src/rlp/tests.rs

@@ -21,7 +21,7 @@ use std::{fmt, cmp};
 use std::str::FromStr;
 use rlp;
 use rlp::{UntrustedRlp, RlpStream, View, Stream, DecoderError};
-use uint::U256;
+use bigint::uint::U256;
 
 #[test]
 fn rlp_at() {