#[macro_export]
macro_rules! assert_0th {
($tuple:expr, value == $val:expr) => {
if &$tuple.0 != $val {
panic!("assertion failed: (tuple.0 == val)\n val: {:?}\ntuple.0: {:?}\n",
$val,
$tuple.0,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.0 == $val {
panic!("assertion failed: (tuple.0 != val)\n val: {:?}\ntuple.0: {:?}\n",
$val,
$tuple.0,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.0 >= $val {
panic!("assertion failed: (tuple.0 < val)\n val: {:?}\ntuple.0: {:?}\n",
$val,
$tuple.0,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.0 > $val {
panic!("assertion failed: (tuple.0 <= val)\n val: {:?}\ntuple.0: {:?}\n",
$val,
$tuple.0,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.0 <= $val {
panic!("assertion failed: (tuple.0 > val)\n val: {:?}\ntuple.0: {:?}\n",
$val,
$tuple.0,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.0 < $val {
panic!("assertion failed: (tuple.0 >= val)\n val: {:?}\ntuple.0: {:?}\n",
$val,
$tuple.0,
);
}
};
}
#[macro_export]
macro_rules! assert_1st {
($tuple:expr, value == $val:expr) => {
if &$tuple.1 != $val {
panic!("assertion failed: (tuple.1 == val)\n val: {:?}\ntuple.1: {:?}\n",
$val,
$tuple.1,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.1 == $val {
panic!("assertion failed: (tuple.1 != val)\n val: {:?}\ntuple.1: {:?}\n",
$val,
$tuple.1,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.1 >= $val {
panic!("assertion failed: (tuple.1 < val)\n val: {:?}\ntuple.1: {:?}\n",
$val,
$tuple.1,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.1 > $val {
panic!("assertion failed: (tuple.1 <= val)\n val: {:?}\ntuple.1: {:?}\n",
$val,
$tuple.1,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.1 <= $val {
panic!("assertion failed: (tuple.1 > val)\n val: {:?}\ntuple.1: {:?}\n",
$val,
$tuple.1,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.1 < $val {
panic!("assertion failed: (tuple.1 >= val)\n val: {:?}\ntuple.1: {:?}\n",
$val,
$tuple.1,
);
}
};
}
#[macro_export]
macro_rules! assert_2nd {
($tuple:expr, value == $val:expr) => {
if &$tuple.2 != $val {
panic!("assertion failed: (tuple.2 == val)\n val: {:?}\ntuple.2: {:?}\n",
$val,
$tuple.2,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.2 == $val {
panic!("assertion failed: (tuple.2 != val)\n val: {:?}\ntuple.2: {:?}\n",
$val,
$tuple.2,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.2 >= $val {
panic!("assertion failed: (tuple.2 < val)\n val: {:?}\ntuple.2: {:?}\n",
$val,
$tuple.2,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.2 > $val {
panic!("assertion failed: (tuple.2 <= val)\n val: {:?}\ntuple.2: {:?}\n",
$val,
$tuple.2,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.2 <= $val {
panic!("assertion failed: (tuple.2 > val)\n val: {:?}\ntuple.2: {:?}\n",
$val,
$tuple.2,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.2 < $val {
panic!("assertion failed: (tuple.2 >= val)\n val: {:?}\ntuple.2: {:?}\n",
$val,
$tuple.2,
);
}
};
}
#[macro_export]
macro_rules! assert_3rd {
($tuple:expr, value == $val:expr) => {
if &$tuple.3 != $val {
panic!("assertion failed: (tuple.3 == val)\n val: {:?}\ntuple.3: {:?}\n",
$val,
$tuple.3,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.3 == $val {
panic!("assertion failed: (tuple.3 != val)\n val: {:?}\ntuple.3: {:?}\n",
$val,
$tuple.3,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.3 >= $val {
panic!("assertion failed: (tuple.3 < val)\n val: {:?}\ntuple.3: {:?}\n",
$val,
$tuple.3,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.3 > $val {
panic!("assertion failed: (tuple.3 <= val)\n val: {:?}\ntuple.3: {:?}\n",
$val,
$tuple.3,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.3 <= $val {
panic!("assertion failed: (tuple.3 > val)\n val: {:?}\ntuple.3: {:?}\n",
$val,
$tuple.3,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.3 < $val {
panic!("assertion failed: (tuple.3 >= val)\n val: {:?}\ntuple.3: {:?}\n",
$val,
$tuple.3,
);
}
};
}
#[macro_export]
macro_rules! assert_4th {
($tuple:expr, value == $val:expr) => {
if &$tuple.4 != $val {
panic!("assertion failed: (tuple.4 == val)\n val: {:?}\ntuple.4: {:?}\n",
$val,
$tuple.4,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.4 == $val {
panic!("assertion failed: (tuple.4 != val)\n val: {:?}\ntuple.4: {:?}\n",
$val,
$tuple.4,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.4 >= $val {
panic!("assertion failed: (tuple.4 < val)\n val: {:?}\ntuple.4: {:?}\n",
$val,
$tuple.4,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.4 > $val {
panic!("assertion failed: (tuple.4 <= val)\n val: {:?}\ntuple.4: {:?}\n",
$val,
$tuple.4,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.4 <= $val {
panic!("assertion failed: (tuple.4 > val)\n val: {:?}\ntuple.4: {:?}\n",
$val,
$tuple.4,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.4 < $val {
panic!("assertion failed: (tuple.4 >= val)\n val: {:?}\ntuple.4: {:?}\n",
$val,
$tuple.4,
);
}
};
}
#[macro_export]
macro_rules! assert_5th {
($tuple:expr, value == $val:expr) => {
if &$tuple.5 != $val {
panic!("assertion failed: (tuple.5 == val)\n val: {:?}\ntuple.5: {:?}\n",
$val,
$tuple.5,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.5 == $val {
panic!("assertion failed: (tuple.5 != val)\n val: {:?}\ntuple.5: {:?}\n",
$val,
$tuple.5,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.5 >= $val {
panic!("assertion failed: (tuple.5 < val)\n val: {:?}\ntuple.5: {:?}\n",
$val,
$tuple.5,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.5 > $val {
panic!("assertion failed: (tuple.5 <= val)\n val: {:?}\ntuple.5: {:?}\n",
$val,
$tuple.5,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.5 <= $val {
panic!("assertion failed: (tuple.5 > val)\n val: {:?}\ntuple.5: {:?}\n",
$val,
$tuple.5,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.5 < $val {
panic!("assertion failed: (tuple.5 >= val)\n val: {:?}\ntuple.5: {:?}\n",
$val,
$tuple.5,
);
}
};
}
#[macro_export]
macro_rules! assert_6th {
($tuple:expr, value == $val:expr) => {
if &$tuple.6 != $val {
panic!("assertion failed: (tuple.6 == val)\n val: {:?}\ntuple.6: {:?}\n",
$val,
$tuple.6,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.6 == $val {
panic!("assertion failed: (tuple.6 != val)\n val: {:?}\ntuple.6: {:?}\n",
$val,
$tuple.6,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.6 >= $val {
panic!("assertion failed: (tuple.6 < val)\n val: {:?}\ntuple.6: {:?}\n",
$val,
$tuple.6,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.6 > $val {
panic!("assertion failed: (tuple.6 <= val)\n val: {:?}\ntuple.6: {:?}\n",
$val,
$tuple.6,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.6 <= $val {
panic!("assertion failed: (tuple.6 > val)\n val: {:?}\ntuple.6: {:?}\n",
$val,
$tuple.6,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.6 < $val {
panic!("assertion failed: (tuple.6 >= val)\n val: {:?}\ntuple.6: {:?}\n",
$val,
$tuple.6,
);
}
};
}
#[macro_export]
macro_rules! assert_7th {
($tuple:expr, value == $val:expr) => {
if &$tuple.7 != $val {
panic!("assertion failed: (tuple.7 == val)\n val: {:?}\ntuple.7: {:?}\n",
$val,
$tuple.7,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.7 == $val {
panic!("assertion failed: (tuple.7 != val)\n val: {:?}\ntuple.7: {:?}\n",
$val,
$tuple.7,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.7 >= $val {
panic!("assertion failed: (tuple.7 < val)\n val: {:?}\ntuple.7: {:?}\n",
$val,
$tuple.7,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.7 > $val {
panic!("assertion failed: (tuple.7 <= val)\n val: {:?}\ntuple.7: {:?}\n",
$val,
$tuple.7,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.7 <= $val {
panic!("assertion failed: (tuple.7 > val)\n val: {:?}\ntuple.7: {:?}\n",
$val,
$tuple.7,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.7 < $val {
panic!("assertion failed: (tuple.7 >= val)\n val: {:?}\ntuple.7: {:?}\n",
$val,
$tuple.7,
);
}
};
}
#[macro_export]
macro_rules! assert_8th {
($tuple:expr, value == $val:expr) => {
if &$tuple.8 != $val {
panic!("assertion failed: (tuple.8 == val)\n val: {:?}\ntuple.8: {:?}\n",
$val,
$tuple.8,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.8 == $val {
panic!("assertion failed: (tuple.8 != val)\n val: {:?}\ntuple.8: {:?}\n",
$val,
$tuple.8,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.8 >= $val {
panic!("assertion failed: (tuple.8 < val)\n val: {:?}\ntuple.8: {:?}\n",
$val,
$tuple.8,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.8 > $val {
panic!("assertion failed: (tuple.8 <= val)\n val: {:?}\ntuple.8: {:?}\n",
$val,
$tuple.8,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.8 <= $val {
panic!("assertion failed: (tuple.8 > val)\n val: {:?}\ntuple.8: {:?}\n",
$val,
$tuple.8,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.8 < $val {
panic!("assertion failed: (tuple.8 >= val)\n val: {:?}\ntuple.8: {:?}\n",
$val,
$tuple.8,
);
}
};
}
#[macro_export]
macro_rules! assert_9th {
($tuple:expr, value == $val:expr) => {
if &$tuple.9 != $val {
panic!("assertion failed: (tuple.9 == val)\n val: {:?}\ntuple.9: {:?}\n",
$val,
$tuple.9,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.9 == $val {
panic!("assertion failed: (tuple.9 != val)\n val: {:?}\ntuple.9: {:?}\n",
$val,
$tuple.9,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.9 >= $val {
panic!("assertion failed: (tuple.9 < val)\n val: {:?}\ntuple.9: {:?}\n",
$val,
$tuple.9,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.9 > $val {
panic!("assertion failed: (tuple.9 <= val)\n val: {:?}\ntuple.9: {:?}\n",
$val,
$tuple.9,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.9 <= $val {
panic!("assertion failed: (tuple.9 > val)\n val: {:?}\ntuple.9: {:?}\n",
$val,
$tuple.9,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.9 < $val {
panic!("assertion failed: (tuple.9 >= val)\n val: {:?}\ntuple.9: {:?}\n",
$val,
$tuple.9,
);
}
};
}
#[macro_export]
macro_rules! assert_10th {
($tuple:expr, value == $val:expr) => {
if &$tuple.10 != $val {
panic!("assertion failed: (tuple.10 == val)\n val: {:?}\ntuple.10: {:?}\n",
$val,
$tuple.10,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.10 == $val {
panic!("assertion failed: (tuple.10 != val)\n val: {:?}\ntuple.10: {:?}\n",
$val,
$tuple.10,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.10 >= $val {
panic!("assertion failed: (tuple.10 < val)\n val: {:?}\ntuple.10: {:?}\n",
$val,
$tuple.10,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.10 > $val {
panic!("assertion failed: (tuple.10 <= val)\n val: {:?}\ntuple.10: {:?}\n",
$val,
$tuple.10,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.10 <= $val {
panic!("assertion failed: (tuple.10 > val)\n val: {:?}\ntuple.10: {:?}\n",
$val,
$tuple.10,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.10 < $val {
panic!("assertion failed: (tuple.10 >= val)\n val: {:?}\ntuple.10: {:?}\n",
$val,
$tuple.10,
);
}
};
}
#[macro_export]
macro_rules! assert_11th {
($tuple:expr, value == $val:expr) => {
if &$tuple.11 != $val {
panic!("assertion failed: (tuple.11 == val)\n val: {:?}\ntuple.11: {:?}\n",
$val,
$tuple.11,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.11 == $val {
panic!("assertion failed: (tuple.11 != val)\n val: {:?}\ntuple.11: {:?}\n",
$val,
$tuple.11,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.11 >= $val {
panic!("assertion failed: (tuple.11 < val)\n val: {:?}\ntuple.11: {:?}\n",
$val,
$tuple.11,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.11 > $val {
panic!("assertion failed: (tuple.11 <= val)\n val: {:?}\ntuple.11: {:?}\n",
$val,
$tuple.11,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.11 <= $val {
panic!("assertion failed: (tuple.11 > val)\n val: {:?}\ntuple.11: {:?}\n",
$val,
$tuple.11,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.11 < $val {
panic!("assertion failed: (tuple.11 >= val)\n val: {:?}\ntuple.11: {:?}\n",
$val,
$tuple.11,
);
}
};
}
#[macro_export]
macro_rules! assert_12th {
($tuple:expr, value == $val:expr) => {
if &$tuple.12 != $val {
panic!("assertion failed: (tuple.12 == val)\n val: {:?}\ntuple.12: {:?}\n",
$val,
$tuple.12,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.12 == $val {
panic!("assertion failed: (tuple.12 != val)\n val: {:?}\ntuple.12: {:?}\n",
$val,
$tuple.12,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.12 >= $val {
panic!("assertion failed: (tuple.12 < val)\n val: {:?}\ntuple.12: {:?}\n",
$val,
$tuple.12,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.12 > $val {
panic!("assertion failed: (tuple.12 <= val)\n val: {:?}\ntuple.12: {:?}\n",
$val,
$tuple.12,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.12 <= $val {
panic!("assertion failed: (tuple.12 > val)\n val: {:?}\ntuple.12: {:?}\n",
$val,
$tuple.12,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.12 < $val {
panic!("assertion failed: (tuple.12 >= val)\n val: {:?}\ntuple.12: {:?}\n",
$val,
$tuple.12,
);
}
};
}
#[macro_export]
macro_rules! assert_13th {
($tuple:expr, value == $val:expr) => {
if &$tuple.13 != $val {
panic!("assertion failed: (tuple.13 == val)\n val: {:?}\ntuple.13: {:?}\n",
$val,
$tuple.13,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.13 == $val {
panic!("assertion failed: (tuple.13 != val)\n val: {:?}\ntuple.13: {:?}\n",
$val,
$tuple.13,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.13 >= $val {
panic!("assertion failed: (tuple.13 < val)\n val: {:?}\ntuple.13: {:?}\n",
$val,
$tuple.13,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.13 > $val {
panic!("assertion failed: (tuple.13 <= val)\n val: {:?}\ntuple.13: {:?}\n",
$val,
$tuple.13,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.13 <= $val {
panic!("assertion failed: (tuple.13 > val)\n val: {:?}\ntuple.13: {:?}\n",
$val,
$tuple.13,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.13 < $val {
panic!("assertion failed: (tuple.13 >= val)\n val: {:?}\ntuple.13: {:?}\n",
$val,
$tuple.13,
);
}
};
}
#[macro_export]
macro_rules! assert_14th {
($tuple:expr, value == $val:expr) => {
if &$tuple.14 != $val {
panic!("assertion failed: (tuple.14 == val)\n val: {:?}\ntuple.14: {:?}\n",
$val,
$tuple.14,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.14 == $val {
panic!("assertion failed: (tuple.14 != val)\n val: {:?}\ntuple.14: {:?}\n",
$val,
$tuple.14,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.14 >= $val {
panic!("assertion failed: (tuple.14 < val)\n val: {:?}\ntuple.14: {:?}\n",
$val,
$tuple.14,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.14 > $val {
panic!("assertion failed: (tuple.14 <= val)\n val: {:?}\ntuple.14: {:?}\n",
$val,
$tuple.14,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.14 <= $val {
panic!("assertion failed: (tuple.14 > val)\n val: {:?}\ntuple.14: {:?}\n",
$val,
$tuple.14,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.14 < $val {
panic!("assertion failed: (tuple.14 >= val)\n val: {:?}\ntuple.14: {:?}\n",
$val,
$tuple.14,
);
}
};
}
#[macro_export]
macro_rules! assert_15th {
($tuple:expr, value == $val:expr) => {
if &$tuple.15 != $val {
panic!("assertion failed: (tuple.15 == val)\n val: {:?}\ntuple.15: {:?}\n",
$val,
$tuple.15,
);
}
};
($tuple:expr, value != $val:expr) => {
if &$tuple.15 == $val {
panic!("assertion failed: (tuple.15 != val)\n val: {:?}\ntuple.15: {:?}\n",
$val,
$tuple.15,
);
}
};
($tuple:expr, value < $val:expr) => {
if &$tuple.15 >= $val {
panic!("assertion failed: (tuple.15 < val)\n val: {:?}\ntuple.15: {:?}\n",
$val,
$tuple.15,
);
}
};
($tuple:expr, value <= $val:expr) => {
if &$tuple.15 > $val {
panic!("assertion failed: (tuple.15 <= val)\n val: {:?}\ntuple.15: {:?}\n",
$val,
$tuple.15,
);
}
};
($tuple:expr, value > $val:expr) => {
if &$tuple.15 <= $val {
panic!("assertion failed: (tuple.15 > val)\n val: {:?}\ntuple.15: {:?}\n",
$val,
$tuple.15,
);
}
};
($tuple:expr, value >= $val:expr) => {
if &$tuple.15 < $val {
panic!("assertion failed: (tuple.15 >= val)\n val: {:?}\ntuple.15: {:?}\n",
$val,
$tuple.15,
);
}
};
}
#[cfg(test)]
mod _15th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value == &16);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value == &15);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value != &15);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value != &16);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value < &17);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value < &16);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value <= &16);
assert_15th!(&tuple, value <= &17);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value <= &15);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value > &15);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value > &16);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value >= &16);
assert_15th!(&tuple, value >= &15);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_15th!(&tuple, value >= &17);
}
}
#[cfg(test)]
mod _14th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value == &15);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value == &14);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value != &14);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value != &15);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value < &16);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value < &15);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value <= &15);
assert_14th!(&tuple, value <= &16);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value <= &14);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value > &14);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value > &15);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value >= &15);
assert_14th!(&tuple, value >= &14);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_14th!(&tuple, value >= &16);
}
}
#[cfg(test)]
mod _13th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value == &14);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value == &13);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value != &13);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value != &14);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value < &15);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value < &14);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value <= &14);
assert_13th!(&tuple, value <= &15);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value <= &13);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value > &13);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value > &14);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value >= &14);
assert_13th!(&tuple, value >= &13);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_13th!(&tuple, value >= &15);
}
}
#[cfg(test)]
mod _12th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value == &13);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value == &12);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value != &12);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value != &13);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value < &14);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value < &13);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value <= &13);
assert_12th!(&tuple, value <= &14);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value <= &12);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value > &12);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value > &13);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value >= &13);
assert_12th!(&tuple, value >= &12);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_12th!(&tuple, value >= &14);
}
}
#[cfg(test)]
mod _11th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value == &12);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value == &11);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value != &11);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value != &12);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value < &13);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value < &12);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value <= &12);
assert_11th!(&tuple, value <= &13);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value <= &11);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value > &11);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value > &12);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value >= &12);
assert_11th!(&tuple, value >= &11);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_11th!(&tuple, value >= &13);
}
}
#[cfg(test)]
mod _10th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value == &11);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value == &10);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value != &10);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value != &11);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value < &12);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value < &11);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value <= &11);
assert_10th!(&tuple, value <= &12);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value <= &10);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value > &10);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value > &11);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value >= &11);
assert_10th!(&tuple, value >= &10);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_10th!(&tuple, value >= &12);
}
}
#[cfg(test)]
mod _09th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value == &10);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value == &9);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value != &9);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value != &10);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value < &11);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value < &10);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value <= &10);
assert_9th!(&tuple, value <= &11);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value <= &9);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value > &9);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value > &10);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value >= &10);
assert_9th!(&tuple, value >= &9);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_9th!(&tuple, value >= &11);
}
}
#[cfg(test)]
mod _08th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value == &9);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value == &8);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value != &8);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value != &9);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value < &10);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value < &9);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value <= &9);
assert_8th!(&tuple, value <= &10);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value <= &8);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value > &8);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value > &9);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value >= &9);
assert_8th!(&tuple, value >= &8);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_8th!(&tuple, value >= &10);
}
}
#[cfg(test)]
mod _07th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value == &8);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value == &7);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value != &7);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value != &8);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value < &9);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value < &8);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value <= &8);
assert_7th!(&tuple, value <= &9);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value <= &7);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value > &7);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value > &8);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value >= &8);
assert_7th!(&tuple, value >= &7);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_7th!(&tuple, value >= &9);
}
}
#[cfg(test)]
mod _06th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value == &7);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value == &6);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value != &6);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value != &7);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value < &8);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value < &7);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value <= &7);
assert_6th!(&tuple, value <= &8);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value <= &6);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value > &6);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value > &7);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value >= &7);
assert_6th!(&tuple, value >= &6);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_6th!(&tuple, value >= &8);
}
}
#[cfg(test)]
mod _05th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value == &6);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value == &5);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value != &5);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value != &6);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value < &7);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value < &6);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value <= &6);
assert_5th!(&tuple, value <= &7);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value <= &5);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value > &5);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value > &6);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value >= &6);
assert_5th!(&tuple, value >= &5);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_5th!(&tuple, value >= &7);
}
}
#[cfg(test)]
mod _04th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value == &5);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value == &4);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value != &4);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value != &5);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value < &6);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value < &5);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value <= &5);
assert_4th!(&tuple, value <= &6);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value <= &4);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value > &4);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value > &5);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value >= &5);
assert_4th!(&tuple, value >= &4);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_4th!(&tuple, value >= &6);
}
}
#[cfg(test)]
mod _03rd {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value == &4);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value == &3);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value != &3);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value != &4);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value < &5);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value < &4);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value <= &4);
assert_3rd!(&tuple, value <= &5);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value <= &3);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value > &3);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value > &4);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value >= &4);
assert_3rd!(&tuple, value >= &3);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_3rd!(&tuple, value >= &5);
}
}
#[cfg(test)]
mod _02nd {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value == &3);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value == &2);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value != &2);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value != &3);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value < &4);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value < &3);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value <= &3);
assert_2nd!(&tuple, value <= &4);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value <= &2);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value > &2);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value > &3);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value >= &3);
assert_2nd!(&tuple, value >= &2);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_2nd!(&tuple, value >= &4);
}
}
#[cfg(test)]
mod _01st {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value == &2);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value == &1);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value != &1);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value != &2);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value < &3);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value < &2);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value <= &2);
assert_1st!(&tuple, value <= &3);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value <= &1);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value > &1);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value > &2);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value >= &2);
assert_1st!(&tuple, value >= &1);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_1st!(&tuple, value >= &3);
}
}
#[cfg(test)]
mod _00th {
#[test]
fn eq_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value == &1);
}
#[test]
#[should_panic]
fn eq_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value == &6);
}
#[test]
fn ne_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value != &2);
}
#[test]
#[should_panic]
fn ne_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value != &1);
}
#[test]
fn lt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value < &2);
}
#[test]
#[should_panic]
fn lt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value < &1);
}
#[test]
fn le_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value <= &1);
assert_0th!(&tuple, value <= &2);
}
#[test]
#[should_panic]
fn le_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value <= &0);
}
#[test]
fn gt_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value > &0);
}
#[test]
#[should_panic]
fn gt_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value > &1);
}
#[test]
fn ge_correct() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value >= &1);
assert_0th!(&tuple, value >= &0);
}
#[test]
#[should_panic]
fn ge_incorrect() {
let tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, "Hello");
assert_0th!(&tuple, value >= &2);
}
}