swaitsandClaude Opus 4.6
3102fc747a
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
760 lines
26 KiB
Rust
760 lines
26 KiB
Rust
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
//! The `version` module gives you tools to create and compare SemVer-compliant
|
|
//! versions.
|
|
|
|
use std::cmp::{self, Ordering};
|
|
use std::fmt;
|
|
use std::hash;
|
|
use std::error::Error;
|
|
|
|
use std::result;
|
|
use std::str;
|
|
|
|
use semver_parser;
|
|
|
|
#[cfg(feature = "serde")]
|
|
use serde::ser::{Serialize, Serializer};
|
|
#[cfg(feature = "serde")]
|
|
use serde::de::{self, Deserialize, Deserializer, Visitor};
|
|
|
|
/// An identifier in the pre-release or build metadata.
|
|
///
|
|
/// See sections 9 and 10 of the spec for more about pre-release identifers and
|
|
/// build metadata.
|
|
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
|
pub enum Identifier {
|
|
/// An identifier that's solely numbers.
|
|
Numeric(u64),
|
|
/// An identifier with letters and numbers.
|
|
AlphaNumeric(String),
|
|
}
|
|
|
|
impl From<semver_parser::version::Identifier> for Identifier {
|
|
fn from(other: semver_parser::version::Identifier) -> Identifier {
|
|
match other {
|
|
semver_parser::version::Identifier::Numeric(n) => Identifier::Numeric(n),
|
|
semver_parser::version::Identifier::AlphaNumeric(s) => Identifier::AlphaNumeric(s),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Identifier {
|
|
#[inline]
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match *self {
|
|
Identifier::Numeric(ref n) => fmt::Display::fmt(n, f),
|
|
Identifier::AlphaNumeric(ref s) => fmt::Display::fmt(s, f),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "serde")]
|
|
impl Serialize for Identifier {
|
|
fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
|
|
where S: Serializer
|
|
{
|
|
// Serialize Identifier as a number or string.
|
|
match *self {
|
|
Identifier::Numeric(n) => serializer.serialize_u64(n),
|
|
Identifier::AlphaNumeric(ref s) => serializer.serialize_str(s),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "serde")]
|
|
impl<'de> Deserialize<'de> for Identifier {
|
|
fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
|
|
where D: Deserializer<'de>
|
|
{
|
|
struct IdentifierVisitor;
|
|
|
|
// Deserialize Identifier from a number or string.
|
|
impl<'de> Visitor<'de> for IdentifierVisitor {
|
|
type Value = Identifier;
|
|
|
|
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
formatter.write_str("a SemVer pre-release or build identifier")
|
|
}
|
|
|
|
fn visit_u64<E>(self, numeric: u64) -> result::Result<Self::Value, E>
|
|
where E: de::Error
|
|
{
|
|
Ok(Identifier::Numeric(numeric))
|
|
}
|
|
|
|
fn visit_str<E>(self, alphanumeric: &str) -> result::Result<Self::Value, E>
|
|
where E: de::Error
|
|
{
|
|
Ok(Identifier::AlphaNumeric(alphanumeric.to_owned()))
|
|
}
|
|
}
|
|
|
|
deserializer.deserialize_any(IdentifierVisitor)
|
|
}
|
|
}
|
|
|
|
/// Represents a version number conforming to the semantic versioning scheme.
|
|
#[derive(Clone, Eq, Debug)]
|
|
pub struct Version {
|
|
/// The major version, to be incremented on incompatible changes.
|
|
pub major: u64,
|
|
/// The minor version, to be incremented when functionality is added in a
|
|
/// backwards-compatible manner.
|
|
pub minor: u64,
|
|
/// The patch version, to be incremented when backwards-compatible bug
|
|
/// fixes are made.
|
|
pub patch: u64,
|
|
/// The pre-release version identifier, if one exists.
|
|
pub pre: Vec<Identifier>,
|
|
/// The build metadata, ignored when determining version precedence.
|
|
pub build: Vec<Identifier>,
|
|
}
|
|
|
|
impl From<semver_parser::version::Version> for Version {
|
|
fn from(other: semver_parser::version::Version) -> Version {
|
|
Version {
|
|
major: other.major,
|
|
minor: other.minor,
|
|
patch: other.patch,
|
|
pre: other.pre.into_iter().map(From::from).collect(),
|
|
build: other.build.into_iter().map(From::from).collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "serde")]
|
|
impl Serialize for Version {
|
|
fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
|
|
where S: Serializer
|
|
{
|
|
// Serialize Version as a string.
|
|
serializer.collect_str(self)
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "serde")]
|
|
impl<'de> Deserialize<'de> for Version {
|
|
fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
|
|
where D: Deserializer<'de>
|
|
{
|
|
struct VersionVisitor;
|
|
|
|
// Deserialize Version from a string.
|
|
impl<'de> Visitor<'de> for VersionVisitor {
|
|
type Value = Version;
|
|
|
|
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
formatter.write_str("a SemVer version as a string")
|
|
}
|
|
|
|
fn visit_str<E>(self, v: &str) -> result::Result<Self::Value, E>
|
|
where E: de::Error
|
|
{
|
|
Version::parse(v).map_err(de::Error::custom)
|
|
}
|
|
}
|
|
|
|
deserializer.deserialize_str(VersionVisitor)
|
|
}
|
|
}
|
|
|
|
/// An error type for this crate
|
|
///
|
|
/// Currently, just a generic error. Will make this nicer later.
|
|
#[derive(Clone,PartialEq,Debug,PartialOrd)]
|
|
pub enum SemVerError {
|
|
/// An error ocurred while parsing.
|
|
ParseError(String),
|
|
}
|
|
|
|
impl fmt::Display for SemVerError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self {
|
|
&SemVerError::ParseError(ref m) => write!(f, "{}", m),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Error for SemVerError {
|
|
fn description(&self) -> &str {
|
|
match self {
|
|
&SemVerError::ParseError(ref m) => m,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A Result type for errors
|
|
pub type Result<T> = result::Result<T, SemVerError>;
|
|
|
|
impl Version {
|
|
|
|
/// Contructs the simple case without pre or build.
|
|
pub fn new(major: u64, minor: u64, patch: u64) -> Version {
|
|
Version {
|
|
major: major,
|
|
minor: minor,
|
|
patch: patch,
|
|
pre: Vec::new(),
|
|
build: Vec::new()
|
|
}
|
|
}
|
|
|
|
/// Parse a string into a semver object.
|
|
pub fn parse(version: &str) -> Result<Version> {
|
|
let res = semver_parser::version::parse(version);
|
|
|
|
match res {
|
|
// Convert plain String error into proper ParseError
|
|
Err(e) => Err(SemVerError::ParseError(e)),
|
|
Ok(v) => Ok(From::from(v)),
|
|
}
|
|
}
|
|
|
|
/// Clears the build metadata
|
|
fn clear_metadata(&mut self) {
|
|
self.build = Vec::new();
|
|
self.pre = Vec::new();
|
|
}
|
|
|
|
/// Increments the patch number for this Version (Must be mutable)
|
|
pub fn increment_patch(&mut self) {
|
|
self.patch += 1;
|
|
self.clear_metadata();
|
|
}
|
|
|
|
/// Increments the minor version number for this Version (Must be mutable)
|
|
///
|
|
/// As instructed by section 7 of the spec, the patch number is reset to 0.
|
|
pub fn increment_minor(&mut self) {
|
|
self.minor += 1;
|
|
self.patch = 0;
|
|
self.clear_metadata();
|
|
}
|
|
|
|
/// Increments the major version number for this Version (Must be mutable)
|
|
///
|
|
/// As instructed by section 8 of the spec, the minor and patch numbers are
|
|
/// reset to 0
|
|
pub fn increment_major(&mut self) {
|
|
self.major += 1;
|
|
self.minor = 0;
|
|
self.patch = 0;
|
|
self.clear_metadata();
|
|
}
|
|
|
|
/// Checks to see if the current Version is in pre-release status
|
|
pub fn is_prerelease(&self) -> bool {
|
|
!self.pre.is_empty()
|
|
}
|
|
}
|
|
|
|
impl str::FromStr for Version {
|
|
type Err = SemVerError;
|
|
|
|
fn from_str(s: &str) -> Result<Version> {
|
|
Version::parse(s)
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Version {
|
|
#[inline]
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
try!(write!(f, "{}.{}.{}", self.major, self.minor, self.patch));
|
|
if !self.pre.is_empty() {
|
|
try!(write!(f, "-"));
|
|
for (i, x) in self.pre.iter().enumerate() {
|
|
if i != 0 {
|
|
try!(write!(f, "."))
|
|
}
|
|
try!(write!(f, "{}", x));
|
|
}
|
|
}
|
|
if !self.build.is_empty() {
|
|
try!(write!(f, "+"));
|
|
for (i, x) in self.build.iter().enumerate() {
|
|
if i != 0 {
|
|
try!(write!(f, "."))
|
|
}
|
|
try!(write!(f, "{}", x));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl cmp::PartialEq for Version {
|
|
#[inline]
|
|
fn eq(&self, other: &Version) -> bool {
|
|
// We should ignore build metadata here, otherwise versions v1 and v2
|
|
// can exist such that !(v1 < v2) && !(v1 > v2) && v1 != v2, which
|
|
// violate strict total ordering rules.
|
|
self.major == other.major && self.minor == other.minor && self.patch == other.patch &&
|
|
self.pre == other.pre
|
|
}
|
|
}
|
|
|
|
impl cmp::PartialOrd for Version {
|
|
fn partial_cmp(&self, other: &Version) -> Option<Ordering> {
|
|
Some(self.cmp(other))
|
|
}
|
|
}
|
|
|
|
impl cmp::Ord for Version {
|
|
fn cmp(&self, other: &Version) -> Ordering {
|
|
match self.major.cmp(&other.major) {
|
|
Ordering::Equal => {}
|
|
r => return r,
|
|
}
|
|
|
|
match self.minor.cmp(&other.minor) {
|
|
Ordering::Equal => {}
|
|
r => return r,
|
|
}
|
|
|
|
match self.patch.cmp(&other.patch) {
|
|
Ordering::Equal => {}
|
|
r => return r,
|
|
}
|
|
|
|
// NB: semver spec says 0.0.0-pre < 0.0.0
|
|
// but the version of ord defined for vec
|
|
// says that [] < [pre] so we alter it here
|
|
match (self.pre.len(), other.pre.len()) {
|
|
(0, 0) => Ordering::Equal,
|
|
(0, _) => Ordering::Greater,
|
|
(_, 0) => Ordering::Less,
|
|
(_, _) => self.pre.cmp(&other.pre),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl hash::Hash for Version {
|
|
fn hash<H: hash::Hasher>(&self, into: &mut H) {
|
|
self.major.hash(into);
|
|
self.minor.hash(into);
|
|
self.patch.hash(into);
|
|
self.pre.hash(into);
|
|
}
|
|
}
|
|
|
|
impl From<(u64,u64,u64)> for Version {
|
|
fn from(tuple: (u64,u64,u64)) -> Version {
|
|
let (major, minor, patch) = tuple;
|
|
Version::new(major, minor, patch)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::result;
|
|
use super::Version;
|
|
use super::Identifier;
|
|
use super::SemVerError;
|
|
|
|
#[test]
|
|
fn test_parse() {
|
|
fn parse_error(e: &str) -> result::Result<Version, SemVerError> {
|
|
return Err(SemVerError::ParseError(e.to_string()));
|
|
}
|
|
|
|
assert_eq!(Version::parse(""),
|
|
parse_error("Error parsing major identifier"));
|
|
assert_eq!(Version::parse(" "),
|
|
parse_error("Error parsing major identifier"));
|
|
assert_eq!(Version::parse("1"),
|
|
parse_error("Expected dot"));
|
|
assert_eq!(Version::parse("1.2"),
|
|
parse_error("Expected dot"));
|
|
assert_eq!(Version::parse("1.2.3-"),
|
|
parse_error("Error parsing prerelease"));
|
|
assert_eq!(Version::parse("a.b.c"),
|
|
parse_error("Error parsing major identifier"));
|
|
assert_eq!(Version::parse("1.2.3 abc"),
|
|
parse_error("Extra junk after valid version: abc"));
|
|
|
|
assert_eq!(Version::parse("1.2.3"),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: Vec::new(),
|
|
}));
|
|
|
|
assert_eq!(Version::parse("1.2.3"),
|
|
Ok(Version::new(1,2,3)));
|
|
|
|
assert_eq!(Version::parse(" 1.2.3 "),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: Vec::new(),
|
|
}));
|
|
assert_eq!(Version::parse("1.2.3-alpha1"),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: Vec::new(),
|
|
}));
|
|
assert_eq!(Version::parse(" 1.2.3-alpha1 "),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: Vec::new(),
|
|
}));
|
|
assert_eq!(Version::parse("1.2.3+build5"),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!(Version::parse(" 1.2.3+build5 "),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!(Version::parse("1.2.3-alpha1+build5"),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!(Version::parse(" 1.2.3-alpha1+build5 "),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!(Version::parse("1.2.3-1.alpha1.9+build5.7.3aedf "),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::Numeric(1),
|
|
Identifier::AlphaNumeric(String::from("alpha1")),
|
|
Identifier::Numeric(9),
|
|
],
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5")),
|
|
Identifier::Numeric(7),
|
|
Identifier::AlphaNumeric(String::from("3aedf")),
|
|
],
|
|
}));
|
|
assert_eq!(Version::parse("0.4.0-beta.1+0851523"),
|
|
Ok(Version {
|
|
major: 0,
|
|
minor: 4,
|
|
patch: 0,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("beta")),
|
|
Identifier::Numeric(1),
|
|
],
|
|
build: vec![Identifier::AlphaNumeric(String::from("0851523"))],
|
|
}));
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn test_increment_patch() {
|
|
let mut buggy_release = Version::parse("0.1.0").unwrap();
|
|
buggy_release.increment_patch();
|
|
assert_eq!(buggy_release, Version::parse("0.1.1").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_increment_minor() {
|
|
let mut feature_release = Version::parse("1.4.6").unwrap();
|
|
feature_release.increment_minor();
|
|
assert_eq!(feature_release, Version::parse("1.5.0").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_increment_major() {
|
|
let mut chrome_release = Version::parse("46.1.246773").unwrap();
|
|
chrome_release.increment_major();
|
|
assert_eq!(chrome_release, Version::parse("47.0.0").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_increment_keep_prerelease() {
|
|
let mut release = Version::parse("1.0.0-alpha").unwrap();
|
|
release.increment_patch();
|
|
|
|
assert_eq!(release, Version::parse("1.0.1").unwrap());
|
|
|
|
release.increment_minor();
|
|
|
|
assert_eq!(release, Version::parse("1.1.0").unwrap());
|
|
|
|
release.increment_major();
|
|
|
|
assert_eq!(release, Version::parse("2.0.0").unwrap());
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn test_increment_clear_metadata() {
|
|
let mut release = Version::parse("1.0.0+4442").unwrap();
|
|
release.increment_patch();
|
|
|
|
assert_eq!(release, Version::parse("1.0.1").unwrap());
|
|
release = Version::parse("1.0.1+hello").unwrap();
|
|
|
|
release.increment_minor();
|
|
|
|
assert_eq!(release, Version::parse("1.1.0").unwrap());
|
|
release = Version::parse("1.1.3747+hello").unwrap();
|
|
|
|
release.increment_major();
|
|
|
|
assert_eq!(release, Version::parse("2.0.0").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_eq() {
|
|
assert_eq!(Version::parse("1.2.3"), Version::parse("1.2.3"));
|
|
assert_eq!(Version::parse("1.2.3-alpha1"),
|
|
Version::parse("1.2.3-alpha1"));
|
|
assert_eq!(Version::parse("1.2.3+build.42"),
|
|
Version::parse("1.2.3+build.42"));
|
|
assert_eq!(Version::parse("1.2.3-alpha1+42"),
|
|
Version::parse("1.2.3-alpha1+42"));
|
|
assert_eq!(Version::parse("1.2.3+23"), Version::parse("1.2.3+42"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_ne() {
|
|
assert!(Version::parse("0.0.0") != Version::parse("0.0.1"));
|
|
assert!(Version::parse("0.0.0") != Version::parse("0.1.0"));
|
|
assert!(Version::parse("0.0.0") != Version::parse("1.0.0"));
|
|
assert!(Version::parse("1.2.3-alpha") != Version::parse("1.2.3-beta"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_show() {
|
|
assert_eq!(format!("{}", Version::parse("1.2.3").unwrap()),
|
|
"1.2.3".to_string());
|
|
assert_eq!(format!("{}", Version::parse("1.2.3-alpha1").unwrap()),
|
|
"1.2.3-alpha1".to_string());
|
|
assert_eq!(format!("{}", Version::parse("1.2.3+build.42").unwrap()),
|
|
"1.2.3+build.42".to_string());
|
|
assert_eq!(format!("{}", Version::parse("1.2.3-alpha1+42").unwrap()),
|
|
"1.2.3-alpha1+42".to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_string() {
|
|
assert_eq!(Version::parse("1.2.3").unwrap().to_string(),
|
|
"1.2.3".to_string());
|
|
assert_eq!(Version::parse("1.2.3-alpha1").unwrap().to_string(),
|
|
"1.2.3-alpha1".to_string());
|
|
assert_eq!(Version::parse("1.2.3+build.42").unwrap().to_string(),
|
|
"1.2.3+build.42".to_string());
|
|
assert_eq!(Version::parse("1.2.3-alpha1+42").unwrap().to_string(),
|
|
"1.2.3-alpha1+42".to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn test_lt() {
|
|
assert!(Version::parse("0.0.0") < Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.0.0") < Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.2.0") < Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.2.3-alpha1") < Version::parse("1.2.3"));
|
|
assert!(Version::parse("1.2.3-alpha1") < Version::parse("1.2.3-alpha2"));
|
|
assert!(!(Version::parse("1.2.3-alpha2") < Version::parse("1.2.3-alpha2")));
|
|
assert!(!(Version::parse("1.2.3+23") < Version::parse("1.2.3+42")));
|
|
}
|
|
|
|
#[test]
|
|
fn test_le() {
|
|
assert!(Version::parse("0.0.0") <= Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.0.0") <= Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.2.0") <= Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.2.3-alpha1") <= Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.2.3-alpha2") <= Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.2.3+23") <= Version::parse("1.2.3+42"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_gt() {
|
|
assert!(Version::parse("1.2.3-alpha2") > Version::parse("0.0.0"));
|
|
assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.0.0"));
|
|
assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.0"));
|
|
assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.3-alpha1"));
|
|
assert!(Version::parse("1.2.3") > Version::parse("1.2.3-alpha2"));
|
|
assert!(!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.3-alpha2")));
|
|
assert!(!(Version::parse("1.2.3+23") > Version::parse("1.2.3+42")));
|
|
}
|
|
|
|
#[test]
|
|
fn test_ge() {
|
|
assert!(Version::parse("1.2.3-alpha2") >= Version::parse("0.0.0"));
|
|
assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.0.0"));
|
|
assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.0"));
|
|
assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.3-alpha1"));
|
|
assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.3-alpha2"));
|
|
assert!(Version::parse("1.2.3+23") >= Version::parse("1.2.3+42"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_prerelease_check() {
|
|
assert!(Version::parse("1.0.0").unwrap().is_prerelease() == false);
|
|
assert!(Version::parse("0.0.1").unwrap().is_prerelease() == false);
|
|
assert!(Version::parse("4.1.4-alpha").unwrap().is_prerelease());
|
|
assert!(Version::parse("1.0.0-beta294296").unwrap().is_prerelease());
|
|
}
|
|
|
|
#[test]
|
|
fn test_spec_order() {
|
|
let vs = ["1.0.0-alpha",
|
|
"1.0.0-alpha.1",
|
|
"1.0.0-alpha.beta",
|
|
"1.0.0-beta",
|
|
"1.0.0-beta.2",
|
|
"1.0.0-beta.11",
|
|
"1.0.0-rc.1",
|
|
"1.0.0"];
|
|
let mut i = 1;
|
|
while i < vs.len() {
|
|
let a = Version::parse(vs[i - 1]);
|
|
let b = Version::parse(vs[i]);
|
|
assert!(a < b, "nope {:?} < {:?}", a, b);
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_from_str() {
|
|
assert_eq!("1.2.3".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: Vec::new(),
|
|
}));
|
|
assert_eq!(" 1.2.3 ".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: Vec::new(),
|
|
}));
|
|
assert_eq!("1.2.3-alpha1".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: Vec::new(),
|
|
}));
|
|
assert_eq!(" 1.2.3-alpha1 ".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: Vec::new(),
|
|
}));
|
|
assert_eq!("1.2.3+build5".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!(" 1.2.3+build5 ".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: Vec::new(),
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!("1.2.3-alpha1+build5".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!(" 1.2.3-alpha1+build5 ".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5"))],
|
|
}));
|
|
assert_eq!("1.2.3-1.alpha1.9+build5.7.3aedf ".parse(),
|
|
Ok(Version {
|
|
major: 1,
|
|
minor: 2,
|
|
patch: 3,
|
|
pre: vec![Identifier::Numeric(1),
|
|
Identifier::AlphaNumeric(String::from("alpha1")),
|
|
Identifier::Numeric(9),
|
|
],
|
|
build: vec![Identifier::AlphaNumeric(String::from("build5")),
|
|
Identifier::Numeric(7),
|
|
Identifier::AlphaNumeric(String::from("3aedf")),
|
|
],
|
|
}));
|
|
assert_eq!("0.4.0-beta.1+0851523".parse(),
|
|
Ok(Version {
|
|
major: 0,
|
|
minor: 4,
|
|
patch: 0,
|
|
pre: vec![Identifier::AlphaNumeric(String::from("beta")),
|
|
Identifier::Numeric(1),
|
|
],
|
|
build: vec![Identifier::AlphaNumeric(String::from("0851523"))],
|
|
}));
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn test_from_str_errors() {
|
|
fn parse_error(e: &str) -> result::Result<Version, SemVerError> {
|
|
return Err(SemVerError::ParseError(e.to_string()));
|
|
}
|
|
|
|
assert_eq!("".parse(), parse_error("Error parsing major identifier"));
|
|
assert_eq!(" ".parse(), parse_error("Error parsing major identifier"));
|
|
assert_eq!("1".parse(), parse_error("Expected dot"));
|
|
assert_eq!("1.2".parse(),
|
|
parse_error("Expected dot"));
|
|
assert_eq!("1.2.3-".parse(),
|
|
parse_error("Error parsing prerelease"));
|
|
assert_eq!("a.b.c".parse(),
|
|
parse_error("Error parsing major identifier"));
|
|
assert_eq!("1.2.3 abc".parse(),
|
|
parse_error("Extra junk after valid version: abc"));
|
|
}
|
|
}
|