diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index 6f3986391..1ef28188b 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -265,7 +265,7 @@ impl<'x> OpenBlock<'x> {
 		let mut s = self;
 		s.engine.on_close_block(&mut s.block);
 		s.block.base.header.transactions_root = ordered_trie_root(s.block.base.transactions.iter().map(|ref e| e.rlp_bytes().to_vec()).collect());
-		let uncle_bytes = s.block.base.uncles.iter().fold(RlpStream::new_list(s.block.base.uncles.len()), |mut s, u| {s.append(&u.rlp(Seal::With)); s} ).out();
+		let uncle_bytes = s.block.base.uncles.iter().fold(RlpStream::new_list(s.block.base.uncles.len()), |mut s, u| {s.append_raw(&u.rlp(Seal::With), 1); s} ).out();
 		s.block.base.header.uncles_hash = uncle_bytes.sha3();
 		s.block.base.header.state_root = s.block.state.root().clone();
 		s.block.base.header.receipts_root = ordered_trie_root(s.block.receipts.iter().map(|ref r| r.rlp_bytes().to_vec()).collect());
@@ -420,4 +420,9 @@ mod tests {
 		assert_eq!(orig_db.keys(), db.keys());
 		assert!(orig_db.keys().iter().filter(|k| orig_db.get(k.0) != db.get(k.0)).next() == None);
 	}
+
+	#[test]
+	fn enact_block_with_uncle() {
+		// TODO: test for when there's an uncle.
+	}
 }
diff --git a/ethcore/src/evm/tests.rs b/ethcore/src/evm/tests.rs
index 53056f79f..445c0be41 100644
--- a/ethcore/src/evm/tests.rs
+++ b/ethcore/src/evm/tests.rs
@@ -55,7 +55,7 @@ struct FakeExt {
 	info: EnvInfo,
 	schedule: Schedule,
 	balances: HashMap<Address, U256>,
-	calls: HashSet<FakeCall>
+	calls: HashSet<FakeCall>,
 }
 
 impl FakeExt {
diff --git a/util/bigint/src/uint.rs b/util/bigint/src/uint.rs
index ea617d570..c3cc6b753 100644
--- a/util/bigint/src/uint.rs
+++ b/util/bigint/src/uint.rs
@@ -1948,8 +1948,6 @@ mod tests {
 
 	#[test]
 	fn u256_multi_muls() {
-		use hash::*;
-
 		let (result, _) = U256([0, 0, 0, 0]).overflowing_mul(U256([0, 0, 0, 0]));
 		assert_eq!(U256([0, 0, 0, 0]), result);
 
@@ -1979,23 +1977,6 @@ mod tests {
 
 		let (result, _) = U256([1, 0, 0, 0]).overflowing_mul(U256([0, 0, 0, ::std::u64::MAX]));
 		assert_eq!(U256([0, 0, 0, ::std::u64::MAX]), result);
-
-		let x1 = U256::from_str("0000000000000000000000000000000000000000000000000000012365124623").unwrap();
-		let x2sqr_right = U256::from_str("000000000000000000000000000000000000000000014baeef72e0378e2328c9").unwrap();
-		let x1sqr = x1 * x1;
-		assert_eq!(H256::from(x2sqr_right), H256::from(x1sqr));
-		let x1cube = x1sqr * x1;
-		let x1cube_right = U256::from_str("0000000000000000000000000000000001798acde139361466f712813717897b").unwrap();
-		assert_eq!(H256::from(x1cube_right), H256::from(x1cube));
-		let x1quad = x1cube * x1;
-		let x1quad_right = U256::from_str("000000000000000000000001adbdd6bd6ff027485484b97f8a6a4c7129756dd1").unwrap();
-		assert_eq!(H256::from(x1quad_right), H256::from(x1quad));
-		let x1penta = x1quad * x1;
-		let x1penta_right = U256::from_str("00000000000001e92875ac24be246e1c57e0507e8c46cc8d233b77f6f4c72993").unwrap();
-		assert_eq!(H256::from(x1penta_right), H256::from(x1penta));
-		let x1septima = x1penta * x1;
-		let x1septima_right = U256::from_str("00022cca1da3f6e5722b7d3cc5bbfb486465ebc5a708dd293042f932d7eee119").unwrap();
-		assert_eq!(H256::from(x1septima_right), H256::from(x1septima));
 	}
 
     #[test]
diff --git a/util/src/bytes.rs b/util/src/bytes.rs
index 2f1b597de..0683ea4df 100644
--- a/util/src/bytes.rs
+++ b/util/src/bytes.rs
@@ -177,7 +177,7 @@ impl<T> BytesConvertable for T where T: AsRef<[u8]> {
 #[test]
 fn bytes_convertable() {
 	assert_eq!(vec![0x12u8, 0x34].bytes(), &[0x12u8, 0x34]);
-	assert!([0u8; 0].bytes().is_empty());
+	assert!([0u8; 0].as_slice().is_empty());
 }
 
 /// Simple trait to allow for raw population of a Sized object from a byte slice.