共享篋：单元测试代码解释

　　在这一节里，实现共享篋每一个模块的单元测试代码。

学习内容

• 了解和学习实现基于不同类型的单元测试方法

篇目

• 模块mod_bare单元测试
• 基于实例的模块mod_trait单元测试
• 基于中间模块的实例单元测试
• 基于中间模块静态函数的类型Box单元测试
• 基于中间模块动态函数的类型Box单元测试
• 参考资料

模块mod_bare单元测试

// File: tests/u_for_mod_bare.rs
// clear && cargo test
// clear && cargo test --package mod_trait_exerci
// $ clear && cargo test --test u_for_mod_bare
#[cfg(test)]
mod tests {
    use mod_trait_exerci::mod_bare;
    use mod_bare::StructType;
    use mod_bare::TupleType;

    #[test]
    fn it_works_with_struct_default() {
        let instance: StructType = Default::default();
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_struct_struct() {
        let instance = StructType{data:(0)};
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_struct() {
        let instance_default: StructType = Default::default();
        let instance_struct = StructType{data:(0)};
        assert_eq!(instance_default, instance_struct);
    }

    #[test]
    fn it_works_with_tuple_default() {
        let instance: TupleType = Default::default();
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_tuple_struct() {
        let instance = TupleType(0);
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_tuple() {
        let instance_default: TupleType = Default::default();
        let instance_tuple = TupleType(0);
        assert_eq!(instance_default, instance_tuple);
    }
}

基于实例的模块mod_trait单元测试

// File: tests/u_for_mod_trait_instance.rs
// clear && cargo test
// clear && cargo test --package mod_trait_exerci
// $ clear && cargo test --test u_for_mod_trait_instance
#[cfg(test)]
mod tests {
    use mod_trait_exerci::mod_trait;
    use mod_trait::TraitCanal;
    use mod_trait::StructType;
    use mod_trait::TupleType;

    #[test]
    fn it_works_with_struct_default() {
        let instance: StructType = Default::default();
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_struct_new() {
        let instance = StructType::new(0);
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_struct() {
        let instance_default: StructType = Default::default();
        let instance_struct = StructType::new(0);
        assert_eq!(instance_default, instance_struct);
    }

    #[test]
    fn it_works_with_tuple_default() {
        let instance: TupleType = Default::default();
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_tuple_struct() {
        let instance = TupleType::new(0);
        assert_eq!(0, instance.get_tuple());
        assert_eq!((0), instance.get_tuple());
    }

    #[test]
    fn it_works_with_tuple() {
        let instance_default: TupleType = Default::default();
        let instance_tuple = TupleType::new(0);
        assert_eq!(instance_default, instance_tuple);
    }
}

基于中间模块的实例单元测试

// File: tests/u_for_mod_trait_fn.rs
// clear && cargo test
// clear && cargo test --package mod_trait_exerci
// $ clear && cargo test --test u_for_mod_trait_fn
#[cfg(test)]
mod tests {
    use mod_trait_exerci::mod_static_fn;
    use mod_trait_exerci::mod_dynamic_fn;
    use mod_trait_exerci::mod_trait;
    use mod_trait::StructType;
    use mod_trait::TupleType;

    #[test]
    fn it_works_with_fn_struct_default() {
        let instance: StructType = Default::default();
        let data = mod_static_fn::get_static_type_ref(&instance);
        assert_eq!(0, data);
        assert_eq!((0), data);
        let data = mod_dynamic_fn::get_dynamic_trait_ref(&instance);
        assert_eq!(0, data);
        assert_eq!((0), data);
    }

    #[test]
    fn it_works_with_fn_tuple_default() {
        let instance: TupleType = Default::default();
        let data = mod_static_fn::get_static_type_ref(&instance);
        assert_eq!(0, data);
        assert_eq!((0), data);
        let data = mod_dynamic_fn::get_dynamic_trait_ref(&instance);
        assert_eq!(0, data);
        assert_eq!((0), data);
    }
}

基于中间模块静态函数的类型Box单元测试

// File: tests/u_for_box_static_hello.rs
// clear && cargo test
// clear && cargo test --package mod_trait_exerci
// clear && cargo test --test u_for_box_static_hello
#[cfg(test)]
mod tests {
    use mod_trait_exerci::mod_box_static_fn;
    use mod_trait_exerci::mod_trait;
    use mod_trait::StructType;
    use mod_trait::TraitCanal;
    use mod_trait::TupleType;

    #[test]
    fn struct_static_box() {
        let instance: StructType = Default::default();
        let instance_box_type: Box<StructType> = Box::new(instance);
        //assert_eq!(0, mod_box_static_fn::get_static_type_ref(&instance_box_type));
        //assert_eq!(0, mod_box_static_fn::get_static_box_ref(&instance));
        assert_eq!(0, mod_box_static_fn::get_static_box_ref(&instance_box_type));
        assert_eq!(0, mod_box_static_fn::get_static_box(instance_box_type));
    }

    #[test]
    fn struct_static_box_ref_and_type_ref() {
        let instance: StructType = Default::default();
        let instance_box_type: Box<&dyn TraitCanal> = Box::new(&instance);
        assert_eq!(0, mod_box_static_fn::get_static_box_and_type_ref(&instance_box_type));
        assert_eq!(0, mod_box_static_fn::get_static_box_type_ref(instance_box_type));
    }

    #[test]
    fn tuple_static_box() {
        let instance: TupleType = Default::default();
        let instance_box_type: Box<TupleType> = Box::new(instance);
        assert_eq!(0, mod_box_static_fn::get_static_box_ref(&instance_box_type));
        assert_eq!(0, mod_box_static_fn::get_static_box(instance_box_type));
    }

    #[test]
    fn tuple_static_box_type() {
        let instance: TupleType = Default::default();
        let instance_box_type: Box<&dyn TraitCanal> = Box::new(&instance);
        assert_eq!(0, mod_box_static_fn::get_static_box_and_type_ref(&instance_box_type));
        assert_eq!(0, mod_box_static_fn::get_static_box_type_ref(instance_box_type));
    }
}

基于中间模块动态函数的类型Box单元测试

// File: tests/u_for_box_dynamic_hello.rs
// clear && cargo test
// clear && cargo test --package mod_trait_exerci
// clear && cargo test --test u_for_box_dynamic_hello
#[cfg(test)]
mod tests {
    use mod_trait_exerci::mod_box_dynamic_fn;
    use mod_trait_exerci::mod_trait;
    use mod_trait::StructType;
    use mod_trait::TraitCanal;
    use mod_trait::TupleType;

    #[test]
    fn struct_dynamic_box() {
        let instance: StructType = Default::default();
        let instance_box_trait: Box<dyn TraitCanal> = Box::new(instance);
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box_ref(&instance_box_trait));
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box(instance_box_trait));
    }

    #[test]
    fn struct_dynamic_box_and_trait() {
        let instance: StructType = Default::default();
        let instance_box_trait: Box<&dyn TraitCanal> = Box::new(&instance);
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box_and_trait_ref(&instance_box_trait));
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box_trait_ref(instance_box_trait));
    }

    #[test]
    fn tulpe_dynamic_box() {
        let instance: TupleType = Default::default();
        let instance_box_trait: Box<dyn TraitCanal> = Box::new(instance);
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box_ref(&instance_box_trait));
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box(instance_box_trait));
    }

    #[test]
    fn tulpe_dynamic_box_trait() {
        let instance: TupleType = Default::default();
        let instance_box_trait: Box<&dyn TraitCanal> = Box::new(&instance);
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box_and_trait_ref(&instance_box_trait));
        assert_eq!(0, mod_box_dynamic_fn::get_dynamic_box_trait_ref(instance_box_trait));
    }
}

参考资料