c_math 0.1.1

use std::io::{Error, ErrorKind};
///用于设置u8中某一位，索引范围为0-7，
///如果超出7会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
pub fn set_bit_to_u8(data: u8, index: u8, value: bool) -> Result<u8, Error> {
    if index > 7 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("index 值超出了U8位的索引范围"),
        ));
    }
    if value {
        Ok(data | (1 << index))
    } else {
        Ok(data & !(1 << index))
    }
}

///用于设置u16中某一位，索引范围为0-15，
///如果超出15会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
pub fn set_bit_to_u16(data: u16, index: u8, value: bool) -> Result<u16, Error> {
    if index > 15 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("index 值超出了U16位的索引范围"),
        ));
    }
    if value {
        Ok(data | (1 << index))
    } else {
        Ok(data & !(1 << index))
    }
}

///用于设置u32中某一位，索引范围为0-31，
///如果超出31会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
pub fn set_bit_to_u32(data: u32, index: u8, value: bool) -> Result<u32, Error> {
    if index > 31 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("index 值超出了U32位的索引范围"),
        ));
    }
    if value {
        Ok(data | (1 << index))
    } else {
        Ok(data & !(1 << index))
    }
}

///用于设置u64中某一位，索引范围为0-63，
///如果超出63会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
pub fn set_bit_to_u64(data: u64, index: u8, value: bool) -> Result<u64, Error> {
    if index > 63 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("index 值超出了U64位的索引范围"),
        ));
    }
    if value {
        Ok(data | (1 << index))
    } else {
        Ok(data & !(1 << index))
    }
}
//设置多位
///用于设置u8中多位，索引范围为0-7，
///如果value的个数超出8会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
///示例 vec![(1,true),(2,false),(3,true)]，把索引1设置为true，索引2设置为false，索引3设置为true
pub fn set_bits_to_u8(data: u8, value: Vec<(u8, bool)>) -> Result<u8, Error> {
    //1，限制value中索引的个数不能超过8个
    if value.iter().count() > 8 || value.iter().count() == 0 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("value的个数值超出了U8位的索引范围或值是空的"),
        ));
    }
    //2，限制value中索引的值不能超过7
    for &item in value.iter().map(|(index, v)| index) {
        if item > 7 {
            return Err(Error::new(
                ErrorKind::InvalidData,
                format!("value中索引的数值超出了7"),
            ));
        }
    }
    let mut data1 = data;
    for &item in value.iter() {
        if item.1 {
            data1 = data1 | (1 << item.0);
        } else {
            data1 = data1 & !(1 << item.0);
        }
    }
    Ok(data1)
}
///用于设置u16中多位，索引范围为0-15，
///如果value的个数超出16会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
///示例 vec![(1,true),(2,false),(3,true)]，把索引1设置为true，索引2设置为false，索引3设置为true
pub fn set_bits_to_u16(data: u16, value: Vec<(u8, bool)>) -> Result<u16, Error> {
    //1，限制value中索引的个数不能超过16个
    if value.iter().count() > 16 || value.iter().count() == 0 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("value的个数值超出了U16位的索引范围或值是空的"),
        ));
    }
    //2，限制value中索引的值不能超过15
    for &item in value.iter().map(|(index, v)| index) {
        if item > 15 {
            return Err(Error::new(
                ErrorKind::InvalidData,
                format!("value中索引的数值超出了15"),
            ));
        }
    }
    let mut data1 = data;
    for &item in value.iter() {
        if item.1 {
            data1 = data1 | (1 << item.0);
        } else {
            data1 = data1 & !(1 << item.0);
        }
    }
    Ok(data1)
}
///用于设置u32中多位，索引范围为0-31，
///如果value的个数超出32会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
///示例 vec![(1,true),(2,false),(3,true)]，把索引1设置为true，索引2设置为false，索引3设置为true
pub fn set_bits_to_u32(data: u32, value: Vec<(u8, bool)>) -> Result<u32, Error> {
    //1，限制value中索引的个数不能超过32个
    if value.iter().count() > 32 || value.iter().count() == 0 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("value的个数值超出了U32位的索引范围或值是空的"),
        ));
    }
    //2，限制value中索引的值不能超过31
    for &item in value.iter().map(|(index, v)| index) {
        if item > 31 {
            return Err(Error::new(
                ErrorKind::InvalidData,
                format!("value中索引的数值超出了31"),
            ));
        }
    }
    let mut data1 = data;
    for &item in value.iter() {
        if item.1 {
            data1 = data1 | (1 << item.0);
        } else {
            data1 = data1 & !(1 << item.0);
        }
    }
    Ok(data1)
}
///用于设置u64中多位，索引范围为0-63，
///如果value的个数超出64会报错，
///未加入大小端参数，由于大小端的不一样，造成数据不一样，可以更改相应的索引
///示例 vec![(1,true),(2,false),(3,true)]，把索引1设置为true，索引2设置为false，索引3设置为true
pub fn set_bits_to_u64(data: u64, value: Vec<(u8, bool)>) -> Result<u64, Error> {
    //1，限制value中索引的个数不能超过64个
    if value.iter().count() > 64 || value.iter().count() == 0 {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("value的个数值超出了U64位的索引范围或值是空的"),
        ));
    }
    //2，限制value中索引的值不能超过63
    for &item in value.iter().map(|(index, v)| index) {
        if item > 63 {
            return Err(Error::new(
                ErrorKind::InvalidData,
                format!("value中索引的数值超出了63"),
            ));
        }
    }
    let mut data1 = data;
    for &item in value.iter() {
        if item.1 {
            data1 = data1 | (1 << item.0);
        } else {
            data1 = data1 & !(1 << item.0);
        }
    }
    Ok(data1)
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn test_set_bit_to_u8() {
        let data: u8 = 0b1010_1010;
        assert_eq!(0b1010_1011, set_bit_to_u8(data, 0, true).unwrap());
        assert_eq!(0b1010_1010, set_bit_to_u8(data, 1, true).unwrap());
        assert_eq!(0b1010_1110, set_bit_to_u8(data, 2, true).unwrap());
        assert_eq!(0b1110_1010, set_bit_to_u8(data, 6, true).unwrap());
        assert_eq!(0b1010_1000, set_bit_to_u8(data, 1, false).unwrap());
        assert_eq!(0b1010_0010, set_bit_to_u8(data, 3, false).unwrap());
        assert_eq!(0b0010_1010, set_bit_to_u8(data, 7, false).unwrap());
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("index 值超出了U8位的索引范围"),
            )
            .to_string(),
            set_bit_to_u8(data, 8, false).unwrap_err().to_string()
        );
    }
    #[test]
    fn test_set_bit_to_u16() {
        let data: u16 = 0b1010_1010_1010_1010;
        assert_eq!(
            0b1010_1010_1010_1011,
            set_bit_to_u16(data, 0, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010,
            set_bit_to_u16(data, 1, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1110,
            set_bit_to_u16(data, 2, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1110_1010,
            set_bit_to_u16(data, 6, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1000,
            set_bit_to_u16(data, 1, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_0010,
            set_bit_to_u16(data, 3, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_0010_1010,
            set_bit_to_u16(data, 7, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010,
            set_bit_to_u16(data, 10, false).unwrap()
        );
        assert_eq!(
            0b1010_1110_1010_1010,
            set_bit_to_u16(data, 10, true).unwrap()
        );
        assert_eq!(
            0b1110_1010_1010_1010,
            set_bit_to_u16(data, 14, true).unwrap()
        );
        assert_eq!(
            0b0010_1010_1010_1010,
            set_bit_to_u16(data, 15, false).unwrap()
        );
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("index 值超出了U16位的索引范围"),
            )
            .to_string(),
            set_bit_to_u16(data, 16, false).unwrap_err().to_string()
        );
    }
    #[test]
    fn test_set_bit_to_u32() {
        let data: u32 = 0b1010_1010_1010_1010_1010_1010_1010_1010;
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1011,
            set_bit_to_u32(data, 0, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u32(data, 1, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1110,
            set_bit_to_u32(data, 2, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1110_1010,
            set_bit_to_u32(data, 6, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1000,
            set_bit_to_u32(data, 1, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_0010,
            set_bit_to_u32(data, 3, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_0010_1010,
            set_bit_to_u32(data, 7, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u32(data, 10, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1110_1010_1010,
            set_bit_to_u32(data, 10, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1110_1010_1010_1010,
            set_bit_to_u32(data, 14, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_0010_1010_1010_1010,
            set_bit_to_u32(data, 15, false).unwrap()
        );
        assert_eq!(
            0b1110_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u32(data, 30, true).unwrap()
        );
        assert_eq!(
            0b0010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u32(data, 31, false).unwrap()
        );
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("index 值超出了U32位的索引范围"),
            )
            .to_string(),
            set_bit_to_u32(data, 32, false).unwrap_err().to_string()
        );
    }
    #[test]
    fn test_set_bit_to_u64() {
        let data: u64 =
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010;
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1011,
            set_bit_to_u64(data, 0, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u64(data, 1, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1110,
            set_bit_to_u64(data, 2, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1110_1010,
            set_bit_to_u64(data, 6, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1000,
            set_bit_to_u64(data, 1, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_0010,
            set_bit_to_u64(data, 3, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_0010_1010,
            set_bit_to_u64(data, 7, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u64(data, 10, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1110_1010_1010,
            set_bit_to_u64(data, 10, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1110_1010_1010_1010,
            set_bit_to_u64(data, 14, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_0010_1010_1010_1010,
            set_bit_to_u64(data, 15, false).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1110_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u64(data, 30, true).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_0010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u64(data, 31, false).unwrap()
        );
        assert_eq!(
            0b1000_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u64(data, 61, false).unwrap()
        );
        assert_eq!(
            0b0010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010,
            set_bit_to_u64(data, 63, false).unwrap()
        );
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("index 值超出了U64位的索引范围"),
            )
            .to_string(),
            set_bit_to_u64(data, 64, false).unwrap_err().to_string()
        );
    }
    #[test]
    fn test_set_bits_to_u8() {
        let data: u8 = 0b1010_1010;
        assert_eq!(
            0b1010_1100,
            set_bits_to_u8(data, vec![(1, false), (2, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010,
            set_bits_to_u8(data, vec![(1, false), (1, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010,
            set_bits_to_u8(data, vec![(7, false), (7, true)]).unwrap()
        );
        assert_eq!(
            0b0101_0101,
            set_bits_to_u8(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false)
                ]
            )
            .unwrap()
        );
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("value的个数值超出了U8位的索引范围或值是空的"),
            )
            .to_string(),
            set_bits_to_u8(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false)
                ]
            )
            .unwrap_err()
            .to_string()
        );
        assert_eq!(
            Error::new(ErrorKind::InvalidData, format!("value中索引的数值超出了7"),).to_string(),
            set_bits_to_u8(data, vec![(0, true), (6, true), (7, false), (8, false)])
                .unwrap_err()
                .to_string()
        );
    }
    #[test]
    fn test_set_bits_to_u16() {
        let data: u16 = 0b1010_1010_1010_1010;
        assert_eq!(
            0b1010_1010_1010_1100,
            set_bits_to_u16(data, vec![(1, false), (2, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010,
            set_bits_to_u16(data, vec![(1, false), (1, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010,
            set_bits_to_u16(data, vec![(7, false), (7, true)]).unwrap()
        );
        assert_eq!(
            0b0101_0101_0101_0101,
            set_bits_to_u16(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, true),
                    (9, false),
                    (10, true),
                    (11, false),
                    (12, true),
                    (13, false),
                    (14, true),
                    (15, false)
                ]
            )
            .unwrap()
        );
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("value的个数值超出了U16位的索引范围或值是空的"),
            )
            .to_string(),
            set_bits_to_u16(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false)
                ]
            )
            .unwrap_err()
            .to_string()
        );
        assert_eq!(
            Error::new(ErrorKind::InvalidData, format!("value中索引的数值超出了15"),).to_string(),
            set_bits_to_u16(data, vec![(0, true), (6, true), (7, false), (16, false)])
                .unwrap_err()
                .to_string()
        );
    }
    #[test]
    fn test_set_bits_to_u32() {
        let data: u32 = 0b1010_1010_1010_1010_1010_1010_1010_1010;
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1100,
            set_bits_to_u32(data, vec![(1, false), (2, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010,
            set_bits_to_u32(data, vec![(1, false), (1, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010,
            set_bits_to_u32(data, vec![(7, false), (7, true)]).unwrap()
        );
        assert_eq!(
            0b0101_0101_0101_0101_0101_0101_0101_0101,
            set_bits_to_u32(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, true),
                    (9, false),
                    (10, true),
                    (11, false),
                    (12, true),
                    (13, false),
                    (14, true),
                    (15, false),
                    (16, true),
                    (17, false),
                    (18, true),
                    (19, false),
                    (20, true),
                    (21, false),
                    (22, true),
                    (23, false),
                    (24, true),
                    (25, false),
                    (26, true),
                    (27, false),
                    (28, true),
                    (29, false),
                    (30, true),
                    (31, false),
                ]
            )
                .unwrap()
        );
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("value的个数值超出了U32位的索引范围或值是空的"),
            )
                .to_string(),
            set_bits_to_u32(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false)
                ]
            )
                .unwrap_err()
                .to_string()
        );
        assert_eq!(
            Error::new(ErrorKind::InvalidData, format!("value中索引的数值超出了31"),).to_string(),
            set_bits_to_u32(data, vec![(0, true), (6, true), (7, false), (32, false)])
                .unwrap_err()
                .to_string()
        );
    }
    #[test]
    fn test_set_bits_to_u64() {
        let data: u64 = 0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010;
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1100,
            set_bits_to_u64(data, vec![(1, false), (2, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010,
            set_bits_to_u64(data, vec![(1, false), (1, true)]).unwrap()
        );
        assert_eq!(
            0b1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010_1010,
            set_bits_to_u64(data, vec![(7, false), (7, true)]).unwrap()
        );
        assert_eq!(
            0b0101_0101_0101_0101_0101_0101_0101_0101_0101_0101_0101_0101_0101_0101_0101_0101,
            set_bits_to_u64(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, true),
                    (9, false),
                    (10, true),
                    (11, false),
                    (12, true),
                    (13, false),
                    (14, true),
                    (15, false),
                    (16, true),
                    (17, false),
                    (18, true),
                    (19, false),
                    (20, true),
                    (21, false),
                    (22, true),
                    (23, false),
                    (24, true),
                    (25, false),
                    (26, true),
                    (27, false),
                    (28, true),
                    (29, false),
                    (30, true),
                    (31, false),
                    (32, true),
                    (33, false),
                    (34, true),
                    (35, false),
                    (36, true),
                    (37, false),
                    (38, true),
                    (39, false),
                    (40, true),
                    (41, false),
                    (42, true),
                    (43, false),
                    (44, true),
                    (45, false),
                    (46, true),
                    (47, false),
                    (48, true),
                    (49, false),
                    (50, true),
                    (51, false),
                    (52, true),
                    (53, false),
                    (54, true),
                    (55, false),
                    (56, true),
                    (57, false),
                    (58, true),
                    (59, false),
                    (60, true),
                    (61, false),
                    (62, true),
                    (63, false),
                ]
            )
                .unwrap()
        );
        assert_eq!(
            Error::new(
                ErrorKind::InvalidData,
                format!("value的个数值超出了U64位的索引范围或值是空的"),
            )
                .to_string(),
            set_bits_to_u64(
                data,
                vec![
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false),
                    (0, true),
                    (1, false),
                    (2, true),
                    (3, false),
                    (4, true),
                    (5, false),
                    (6, true),
                    (7, false),
                    (8, false)
                ]
            )
                .unwrap_err()
                .to_string()
        );
        assert_eq!(
            Error::new(ErrorKind::InvalidData, format!("value中索引的数值超出了63"),).to_string(),
            set_bits_to_u64(data, vec![(0, true), (6, true), (7, false), (64, false)])
                .unwrap_err()
                .to_string()
        );
    }
}