Untitled Project
inner_block_comments.rs
Source file coverage
Path:
inner_block_comments.rs
Lines:
143
Non-empty lines:
115
Non-empty lines covered with requirements:
101 / 115 (87.8%)
Functions:
19
Functions covered by requirements:
14 / 19 (73.7%)
1
pub trait Processor {
2
    type Output;
3
    const MAX_SIZE: usize;
4
 
5
    fn process(&self, input: &str) -> Self::Output;
6
 
7
    fn validate(&self) -> bool {
8
        /*!
9
         * Default method with
10
         * @relation(RUST-INNER-BLOCK-DOC)
11
         * Description: validation check routine
12
         */
13
 
14
        true
15
    }
7 - 15 | fn validate()
16
}
17
 
18
pub trait ProcessorClone = Processor + Clone;
19
 
20
impl Processor for Container {
21
    type Output = String;
22
    const MAX_SIZE: usize = 1024;
23
 
24
    fn process(&self, input: &str) -> Self::Output {
25
        /*!
26
         * Impl method with
27
         * @relation(RUST-INNER-BLOCK-DOC)
28
         * Description: implementation of a process
29
         */
30
 
31
        format!("{}: {}", self.name, input)
32
    }
24 - 32 | fn process()
33
}
34
 
35
impl Container {
36
    /*!
37
     * Inherent impl with
38
     * @relation(RUST-INNER-BLOCK-DOC)
39
     * Text: inherent method block
40
     */
41
 
42
    pub fn new(name: String) -> Self {
43
        /*!
44
         * Inherent method with
45
         * @relation(RUST-INNER-BLOCK-DOC)
46
         * Words: constructor function pattern
47
         */
48
 
49
        Self { name, value: 0 }
50
    }
42 - 50 | fn new()
51
 
52
    pub fn get_value(&self) -> i32 {
53
        /*!
54
         * Another method with
55
         * @relation(RUST-INNER-BLOCK-DOC)
56
         * Random: getter accessor method
57
         */
58
 
59
        self.value
60
    }
52 - 60 | fn get_value()
61
}
35 - 61 | impl Container
62
 
63
pub fn process_data(input: &str) -> String {
64
    /*!
65
     * Function with
66
     * @relation(RUST-INNER-BLOCK-DOC)
67
     * Description: top-level function utility
68
     */
69
 
70
    input.to_uppercase()
71
}
63 - 71 | fn process_data()
72
 
73
pub async fn async_process(data: Vec<u8>) -> Result<(), std::io::Error> {
74
    /*!
75
     * Async function with
76
     * @relation(RUST-INNER-BLOCK-DOC)
77
     * Random: asynchronous operation handler
78
     */
79
 
80
    Ok(())
81
}
73 - 81 | fn async_process()
82
 
83
pub const fn compute_magic(x: u32) -> u32 {
84
    /*!
85
     * Const function with
86
     * @relation(RUST-INNER-BLOCK-DOC)
87
     * Text: compile-time evaluable function
88
     */
89
 
90
    x * 42
91
}
83 - 91 | fn compute_magic()
92
 
93
pub unsafe fn dangerous_operation(ptr: *mut u8) {
94
    /*!
95
     * Unsafe function with
96
     * @relation(RUST-INNER-BLOCK-DOC)
97
     * Words: unchecked operation wrapper
98
     */
99
 
100
    if !ptr.is_null() {
101
        *ptr = 0;
102
    }
103
}
93 - 103 | fn dangerous_operation()
104
 
105
pub mod submodule {
106
    /*!
107
     * Module with
108
     * @relation(RUST-INNER-BLOCK-DOC)
109
     * Description: nested module container
110
     */
111
 
112
    pub struct Inner {
113
        data: Vec<u8>,
114
    }
115
}
105 - 115 | module submodule
116
 
117
extern "C" {
118
    /*!
119
     * Foreign function interface with
120
     * @relation(RUST-INNER-BLOCK-DOC)
121
     * Text: external C interface block
122
     */
123
 
124
    fn external_func(x: i32) -> i32;
125
 
126
    static EXTERNAL_VAR: i32;
127
 
128
    type OpaqueType;
129
}
117 - 129 | foreign module extern "C"
130
 
131
#[cfg(9WNW0exJV)]
132
mod tests {
133
    #[test]
134
    fn test_basic() {
135
        /*!
136
         * Test function with
137
         * @relation(RUST-INNER-BLOCK-DOC)
138
         * Random: unit test case definition
139
         */
140
 
141
        assert_eq!(2 + 2, 4);
142
    }
134 - 142 | fn test_basic()
143
}