Generic Normalize impl for arithmetic and npos-elections (#6374)

* add normalize

* better api for normalize

* Some grumbles

* Update primitives/arithmetic/src/lib.rs

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>

* More great review grumbles

* Way better doc for everything.

* Some improvement

* Update primitives/arithmetic/src/lib.rs

Co-authored-by: Bernhard Schuster <bernhard@ahoi.io>

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>
Co-authored-by: Bernhard Schuster <bernhard@ahoi.io>

substrate/primitives/arithmetic/fuzzer/Cargo.toml

@@ -24,6 +24,10 @@ num-traits = "0.2"
 name = "biguint"
 path = "src/biguint.rs"
 
+[[bin]]
+name = "normalize"
+path = "src/normalize.rs"
+
 [[bin]]
 name = "per_thing_rational"
 path = "src/per_thing_rational.rs"

substrate/primitives/arithmetic/fuzzer/src/normalize.rs

@@ -0,0 +1,62 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run normalize`. `honggfuzz` CLI options can
+//! be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug normalize hfuzz_workspace/normalize/*.fuzz`.
+
+use honggfuzz::fuzz;
+use sp_arithmetic::Normalizable;
+use std::convert::TryInto;
+
+fn main() {
+	let sum_limit = u32::max_value() as u128;
+	let len_limit: usize = u32::max_value().try_into().unwrap();
+
+	loop {
+		fuzz!(|data: (Vec<u32>, u32)| {
+			let (data, norm) = data;
+			if data.len() == 0 { return; }
+			let pre_sum: u128 = data.iter().map(|x| *x as u128).sum();
+
+			let normalized = data.normalize(norm);
+			// error cases.
+			if pre_sum > sum_limit || data.len() > len_limit {
+				assert!(normalized.is_err())
+			} else {
+				if let Ok(normalized) = normalized {
+					// if sum goes beyond u128, panic.
+					let sum: u128 = normalized.iter().map(|x| *x as u128).sum();
+
+					// if this function returns Ok(), then it will ALWAYS be accurate.
+					assert_eq!(
+						sum,
+						norm as u128,
+						"sums don't match {:?}, {}",
+						normalized,
+						norm,
+					);
+				}
+			}
+		})
+	}
+}

substrate/primitives/arithmetic/fuzzer/src/per_thing_rational.rs

@@ -114,7 +114,7 @@ fn main() {
 	}
 }
 
-fn assert_per_thing_equal_error<T: PerThing>(a: T, b: T, err: u128) {
+fn assert_per_thing_equal_error<P: PerThing>(a: P, b: P, err: u128) {
 	let a_abs = a.deconstruct().saturated_into::<u128>();
 	let b_abs = b.deconstruct().saturated_into::<u128>();
 	let diff = a_abs.max(b_abs) - a_abs.min(b_abs);