bitcoin-version 0.1.19

tools related to versioning
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// ---------------- [ File: bitcoin-version/src/clientversion.rs ]
crate::ix!();

//-------------------------------------------[.cpp/bitcoin/src/clientversion.h]

///-----------------
pub fn format_version(n_version: i32) -> String {
    
    format!(
        "{}.{}.{}",
        n_version / 10000,
        (n_version / 100) % 100,
        n_version % 100
    )

}

#[cfg(not(WINDRES_PREPROC))]
pub fn format_full_version() -> String {
    trace!("constructing full version string");

    #[cfg(BUILD_GIT_TAG)]
    {
        let full = format!("{}{}", BUILD_DESC, BUILD_SUFFIX);
        debug!(%full, "full version string (tagged build)");
        full
    }

    #[cfg(not(BUILD_GIT_TAG))]
    {
        let full = format!("{}{}", &*BUILD_DESC, &*BUILD_SUFFIX);
        debug!(%full, "full version string (untagged build)");
        full
    }
}

/**
  | Format the sub‑version field according to BIP 14
  | (https://github.com/bitcoin/bips/blob/master/bip-0014.mediawiki)
  */
#[cfg(not(WINDRES_PREPROC))]
pub fn format_sub_version(
    name:             &String,
    n_client_version: i32,
    comments:         &Vec<String>,
) -> String {
    trace!(
        client = %name,
        version = n_client_version,
        comments = ?comments,
        "format_sub_version invoked"
    );

    let mut out = String::with_capacity(32);
    out.push('/');
    out.push_str(name);
    out.push(':');
    out.push_str(&format_version(n_client_version));

    if !comments.is_empty() {
        out.push('(');
        let mut first = true;
        for c in comments {
            if !first {
                out.push_str("; ");
            }
            out.push_str(c);
            first = false;
        }
        out.push(')');
    }

    out.push('/');
    debug!(formatted = %out, "sub‑version formatted");
    out
}

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

    #[traced_test]
    fn format_version_matches_expected() {
        let expected = "22.99.0";
        let actual   = format_version(super::CLIENT_VERSION);
        info!("format_version produced {}", actual);
        assert_eq!(actual, expected);
    }

    #[traced_test]
    fn full_version_non_empty() {
        let full = format_full_version();
        info!("format_full_version produced {}", full);
        assert!(!full.is_empty(), "full version string must not be empty");
    }

    #[traced_test]
    fn sub_version_round_trip() {
        let name      = String::from(super::CLIENT_NAME);
        let comments  = vec![String::from("alpha"), String::from("beta")];

        let expected  = format!(
            "/{}:{}({}; {})/",
            name,
            format_version(super::CLIENT_VERSION),
            comments[0],
            comments[1]
        );

        let actual = format_sub_version(&name, super::CLIENT_VERSION, &comments);
        info!("format_sub_version produced {}", actual);
        assert_eq!(actual, expected);
    }

    #[traced_test]
    fn sub_version_without_comments() {
        let name      = String::from(super::CLIENT_NAME);
        let comments  = Vec::new();

        let expected  = format!(
            "/{}:{}/",
            name,
            format_version(super::CLIENT_VERSION)
        );

        let actual = format_sub_version(&name, super::CLIENT_VERSION, &comments);
        info!("format_sub_version (no comments) produced {}", actual);
        assert_eq!(actual, expected);
    }
}