Freestyle Sparring

import codewars_test as test
import inspect
import solution # from solution

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Test of compression text")
def test_group():
    # todo please, correct this number after make cnage
    method_size=504
    module_size=504
    
    text_size=464
    text_expected="""Compress large text - description of this Kata or Kumite in small code.
This Kata or Kumite description has 462 symbols in 3 line, without title. You should wrote function, return this text, but you should use less symbols in you'r code that this text. Simple solution - just return \"\"\"source text\"\"\". More smart variant is: do mark often word as special symbols and replace his before return.
How small code can be? Can you wrote more compressing? Let's check it!"""
    
    @test.it("Text check")
    def test_case_text():
        expected = text_expected
        test.assert_equals(solution.text(), expected)
        test.assert_equals(solution.text(), expected)
    
    @test.it("Test of test")
    def test_text():
        expected = text_expected
        test.assert_equals(len(text_expected), text_size)
        src=inspect.getsource(solution)
        src_len=len(src)
        test.assert_equals((src_len>= 5),True, "Test not see solution source")
    
    @test.it("Source function check")
    def test_case_source_function():
        src=inspect.getsource(solution.text)
        src_len=len(src)
        #test.assert_equals(src, "see method")
        print("Size of source code 'def test()' is "+str(src_len))
        test.assert_equals((src_len<= method_size),True, "Function 'def test()' too large: "+str(src_len))
        test.assert_equals((src_len>= 4),True, "How wrote methd more small that he's call?") # test should see method
        if src_len< method_size: print(f"New function less up to {method_size-src_len} symbol!")
    
    @test.it("Source module check")
    def test_case_source_function():
        src=inspect.getsource(solution)
        src_len=len(src)
        print("Size of all source code length is "+str(src_len))
        test.assert_equals((src_len<= module_size),True, "Source code of all module too large: "+str(src_len)+". Do not hidde data out of the function.")
        if src_len< module_size: print(f"New code less up to {module_size-src_len} symbol!")
        if (src_len<text_size): print(f"Congradulation! The code less that text at {text_size-src_len} symbol.")

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_even_numbers_in_array() {
        let v = &[-567, 2, 100, -34, 1000, 99, 101, -1000, 200, 7, -100];
        let r = v.iter().fold(0, |count, &num| count + (num & 1 == 0) as usize);
        assert_eq!(calculate_even_numbers(v), r);
    }

    #[test]
    fn test_empty_array() {
        assert_eq!(calculate_even_numbers(&[]), 0);
    }

    #[test]
    fn test_no_even_numbers() {
        let v = &[5, 7, 9, 1, 21, 33, 77, 57, 33, 91, 111, 23451];
        assert_eq!(calculate_even_numbers(v), 0);
    }

    #[test]
    fn test_multiple_even_numbers() {
        let v = &[60, 180, 99, 100, 101, 103];
        assert_eq!(calculate_even_numbers(v), 3);
    }

    #[test]
    fn test_large_numbers() {
        let v = &[10_000_000, 90_000, 700_000_000, 2, 70, 44];
        assert_eq!(calculate_even_numbers(v), 6);
    }
}