[rustc.git] / vendor / semver / src / version.rs

// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT\r
// file at the top-level directory of this distribution and at\r
// http://rust-lang.org/COPYRIGHT.\r
//\r
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\r
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\r
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\r
// option. This file may not be copied, modified, or distributed\r
// except according to those terms.\r
\r
//! The `version` module gives you tools to create and compare SemVer-compliant\r
//! versions.\r
\r
use std::cmp::{self, Ordering};\r
use std::error::Error;\r
use std::fmt;\r
use std::hash;\r
\r
use std::result;\r
use std::str;\r
\r
use semver_parser;\r
\r
#[cfg(feature = "serde")]\r
use serde::de::{self, Deserialize, Deserializer, Visitor};\r
#[cfg(feature = "serde")]\r
use serde::ser::{Serialize, Serializer};\r
\r
/// An identifier in the pre-release or build metadata.\r
///\r
/// See sections 9 and 10 of the spec for more about pre-release identifers and\r
/// build metadata.\r
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]\r
pub enum Identifier {\r
    /// An identifier that's solely numbers.\r
    Numeric(u64),\r
    /// An identifier with letters and numbers.\r
    AlphaNumeric(String),\r
}\r
\r
impl From<semver_parser::version::Identifier> for Identifier {\r
    fn from(other: semver_parser::version::Identifier) -> Identifier {\r
        match other {\r
            semver_parser::version::Identifier::Numeric(n) => Identifier::Numeric(n),\r
            semver_parser::version::Identifier::AlphaNumeric(s) => Identifier::AlphaNumeric(s),\r
        }\r
    }\r
}\r
\r
impl fmt::Display for Identifier {\r
    #[inline]\r
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\r
        match *self {\r
            Identifier::Numeric(ref n) => fmt::Display::fmt(n, f),\r
            Identifier::AlphaNumeric(ref s) => fmt::Display::fmt(s, f),\r
        }\r
    }\r
}\r
\r
#[cfg(feature = "serde")]\r
impl Serialize for Identifier {\r
    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>\r
    where\r
        S: Serializer,\r
    {\r
        // Serialize Identifier as a number or string.\r
        match *self {\r
            Identifier::Numeric(n) => serializer.serialize_u64(n),\r
            Identifier::AlphaNumeric(ref s) => serializer.serialize_str(s),\r
        }\r
    }\r
}\r
\r
#[cfg(feature = "serde")]\r
impl<'de> Deserialize<'de> for Identifier {\r
    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>\r
    where\r
        D: Deserializer<'de>,\r
    {\r
        struct IdentifierVisitor;\r
\r
        // Deserialize Identifier from a number or string.\r
        impl<'de> Visitor<'de> for IdentifierVisitor {\r
            type Value = Identifier;\r
\r
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\r
                formatter.write_str("a SemVer pre-release or build identifier")\r
            }\r
\r
            fn visit_u64<E>(self, numeric: u64) -> result::Result<Self::Value, E>\r
            where\r
                E: de::Error,\r
            {\r
                Ok(Identifier::Numeric(numeric))\r
            }\r
\r
            fn visit_str<E>(self, alphanumeric: &str) -> result::Result<Self::Value, E>\r
            where\r
                E: de::Error,\r
            {\r
                Ok(Identifier::AlphaNumeric(alphanumeric.to_owned()))\r
            }\r
        }\r
\r
        deserializer.deserialize_any(IdentifierVisitor)\r
    }\r
}\r
\r
/// Represents a version number conforming to the semantic versioning scheme.\r
#[derive(Clone, Eq, Debug)]\r
#[cfg_attr(feature = "diesel", derive(AsExpression, FromSqlRow))]\r
#[cfg_attr(feature = "diesel", sql_type = "diesel::sql_types::Text")]\r
pub struct Version {\r
    /// The major version, to be incremented on incompatible changes.\r
    pub major: u64,\r
    /// The minor version, to be incremented when functionality is added in a\r
    /// backwards-compatible manner.\r
    pub minor: u64,\r
    /// The patch version, to be incremented when backwards-compatible bug\r
    /// fixes are made.\r
    pub patch: u64,\r
    /// The pre-release version identifier, if one exists.\r
    pub pre: Vec<Identifier>,\r
    /// The build metadata, ignored when determining version precedence.\r
    pub build: Vec<Identifier>,\r
}\r
\r
impl From<semver_parser::version::Version> for Version {\r
    fn from(other: semver_parser::version::Version) -> Version {\r
        Version {\r
            major: other.major,\r
            minor: other.minor,\r
            patch: other.patch,\r
            pre: other.pre.into_iter().map(From::from).collect(),\r
            build: other.build.into_iter().map(From::from).collect(),\r
        }\r
    }\r
}\r
\r
#[cfg(feature = "serde")]\r
impl Serialize for Version {\r
    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>\r
    where\r
        S: Serializer,\r
    {\r
        // Serialize Version as a string.\r
        serializer.collect_str(self)\r
    }\r
}\r
\r
#[cfg(feature = "serde")]\r
impl<'de> Deserialize<'de> for Version {\r
    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>\r
    where\r
        D: Deserializer<'de>,\r
    {\r
        struct VersionVisitor;\r
\r
        // Deserialize Version from a string.\r
        impl<'de> Visitor<'de> for VersionVisitor {\r
            type Value = Version;\r
\r
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\r
                formatter.write_str("a SemVer version as a string")\r
            }\r
\r
            fn visit_str<E>(self, v: &str) -> result::Result<Self::Value, E>\r
            where\r
                E: de::Error,\r
            {\r
                Version::parse(v).map_err(de::Error::custom)\r
            }\r
        }\r
\r
        deserializer.deserialize_str(VersionVisitor)\r
    }\r
}\r
\r
/// An error type for this crate\r
///\r
/// Currently, just a generic error. Will make this nicer later.\r
#[derive(Clone, PartialEq, Debug, PartialOrd)]\r
pub enum SemVerError {\r
    /// An error ocurred while parsing.\r
    ParseError(String),\r
}\r
\r
impl fmt::Display for SemVerError {\r
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\r
        match self {\r
            SemVerError::ParseError(ref m) => write!(f, "{}", m),\r
        }\r
    }\r
}\r
\r
impl Error for SemVerError {}\r
\r
/// A Result type for errors\r
pub type Result<T> = result::Result<T, SemVerError>;\r
\r
impl Version {\r
    /// Contructs the simple case without pre or build.\r
    pub fn new(major: u64, minor: u64, patch: u64) -> Version {\r
        Version {\r
            major,\r
            minor,\r
            patch,\r
            pre: Vec::new(),\r
            build: Vec::new(),\r
        }\r
    }\r
\r
    /// Parse a string into a semver object.\r
    ///\r
    /// # Errors\r
    ///\r
    /// Returns an error variant if the input could not be parsed as a semver object.\r
    ///\r
    /// In general, this means that the provided string does not conform to the\r
    /// [semver spec][semver].\r
    ///\r
    /// An error for overflow is returned if any numeric component is larger than what can be\r
    /// stored in `u64`.\r
    ///\r
    /// The following are examples for other common error causes:\r
    ///\r
    /// * `1.0` - too few numeric components are used. Exactly 3 are expected.\r
    /// * `1.0.01` - a numeric component has a leading zero.\r
    /// * `1.0.foo` - uses a non-numeric components where one is expected.\r
    /// * `1.0.0foo` - metadata is not separated using a legal character like, `+` or `-`.\r
    /// * `1.0.0+foo_123` - contains metadata with an illegal character (`_`).\r
    ///   Legal characters for metadata include `a-z`, `A-Z`, `0-9`, `-`, and `.` (dot).\r
    ///\r
    /// [semver]: https://semver.org\r
    pub fn parse(version: &str) -> Result<Version> {\r
        let res = semver_parser::version::parse(version);\r
\r
        match res {\r
            // Convert plain String error into proper ParseError\r
            Err(e) => Err(SemVerError::ParseError(e)),\r
            Ok(v) => Ok(From::from(v)),\r
        }\r
    }\r
\r
    /// Clears the build metadata\r
    fn clear_metadata(&mut self) {\r
        self.build = Vec::new();\r
        self.pre = Vec::new();\r
    }\r
\r
    /// Increments the patch number for this Version (Must be mutable)\r
    pub fn increment_patch(&mut self) {\r
        self.patch += 1;\r
        self.clear_metadata();\r
    }\r
\r
    /// Increments the minor version number for this Version (Must be mutable)\r
    ///\r
    /// As instructed by section 7 of the spec, the patch number is reset to 0.\r
    pub fn increment_minor(&mut self) {\r
        self.minor += 1;\r
        self.patch = 0;\r
        self.clear_metadata();\r
    }\r
\r
    /// Increments the major version number for this Version (Must be mutable)\r
    ///\r
    /// As instructed by section 8 of the spec, the minor and patch numbers are\r
    /// reset to 0\r
    pub fn increment_major(&mut self) {\r
        self.major += 1;\r
        self.minor = 0;\r
        self.patch = 0;\r
        self.clear_metadata();\r
    }\r
\r
    /// Checks to see if the current Version is in pre-release status\r
    pub fn is_prerelease(&self) -> bool {\r
        !self.pre.is_empty()\r
    }\r
}\r
\r
impl str::FromStr for Version {\r
    type Err = SemVerError;\r
\r
    fn from_str(s: &str) -> Result<Version> {\r
        Version::parse(s)\r
    }\r
}\r
\r
impl fmt::Display for Version {\r
    #[inline]\r
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\r
        let mut result = format!("{}.{}.{}", self.major, self.minor, self.patch);\r
\r
        if !self.pre.is_empty() {\r
            result.push_str("-");\r
            for (i, x) in self.pre.iter().enumerate() {\r
                if i != 0 {\r
                    result.push_str(".");\r
                }\r
                result.push_str(format!("{}", x).as_ref());\r
            }\r
        }\r
        if !self.build.is_empty() {\r
            result.push_str("+");\r
            for (i, x) in self.build.iter().enumerate() {\r
                if i != 0 {\r
                    result.push_str(".");\r
                }\r
                result.push_str(format!("{}", x).as_ref());\r
            }\r
        }\r
\r
        f.pad(result.as_ref())?;\r
        Ok(())\r
    }\r
}\r
\r
impl cmp::PartialEq for Version {\r
    #[inline]\r
    fn eq(&self, other: &Version) -> bool {\r
        // We should ignore build metadata here, otherwise versions v1 and v2\r
        // can exist such that !(v1 < v2) && !(v1 > v2) && v1 != v2, which\r
        // violate strict total ordering rules.\r
        self.major == other.major\r
            && self.minor == other.minor\r
            && self.patch == other.patch\r
            && self.pre == other.pre\r
    }\r
}\r
\r
impl cmp::PartialOrd for Version {\r
    fn partial_cmp(&self, other: &Version) -> Option<Ordering> {\r
        Some(self.cmp(other))\r
    }\r
}\r
\r
impl cmp::Ord for Version {\r
    fn cmp(&self, other: &Version) -> Ordering {\r
        match self.major.cmp(&other.major) {\r
            Ordering::Equal => {}\r
            r => return r,\r
        }\r
\r
        match self.minor.cmp(&other.minor) {\r
            Ordering::Equal => {}\r
            r => return r,\r
        }\r
\r
        match self.patch.cmp(&other.patch) {\r
            Ordering::Equal => {}\r
            r => return r,\r
        }\r
\r
        // NB: semver spec says 0.0.0-pre < 0.0.0\r
        // but the version of ord defined for vec\r
        // says that [] < [pre] so we alter it here\r
        match (self.pre.len(), other.pre.len()) {\r
            (0, 0) => Ordering::Equal,\r
            (0, _) => Ordering::Greater,\r
            (_, 0) => Ordering::Less,\r
            (_, _) => self.pre.cmp(&other.pre),\r
        }\r
    }\r
}\r
\r
impl hash::Hash for Version {\r
    fn hash<H: hash::Hasher>(&self, into: &mut H) {\r
        self.major.hash(into);\r
        self.minor.hash(into);\r
        self.patch.hash(into);\r
        self.pre.hash(into);\r
    }\r
}\r
\r
impl From<(u64, u64, u64)> for Version {\r
    fn from(tuple: (u64, u64, u64)) -> Version {\r
        let (major, minor, patch) = tuple;\r
        Version::new(major, minor, patch)\r
    }\r
}\r
\r
#[cfg(test)]\r
mod tests {\r
    use super::Identifier;\r
    use super::SemVerError;\r
    use super::Version;\r
    use std::result;\r
\r
    #[test]\r
    fn test_parse() {\r
        fn parse_error(e: &str) -> result::Result<Version, SemVerError> {\r
            return Err(SemVerError::ParseError(e.to_string()));\r
        }\r
\r
        assert_eq!(\r
            Version::parse(""),\r
            parse_error("Error parsing major identifier")\r
        );\r
        assert_eq!(\r
            Version::parse("  "),\r
            parse_error("Error parsing major identifier")\r
        );\r
        assert_eq!(Version::parse("1"), parse_error("Expected dot"));\r
        assert_eq!(Version::parse("1.2"), parse_error("Expected dot"));\r
        assert_eq!(\r
            Version::parse("1.2.3-"),\r
            parse_error("Error parsing prerelease")\r
        );\r
        assert_eq!(\r
            Version::parse("a.b.c"),\r
            parse_error("Error parsing major identifier")\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3 abc"),\r
            parse_error("Extra junk after valid version:  abc")\r
        );\r
\r
        assert_eq!(\r
            Version::parse("1.2.3"),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: Vec::new(),\r
            })\r
        );\r
\r
        assert_eq!(Version::parse("1.2.3"), Ok(Version::new(1, 2, 3)));\r
\r
        assert_eq!(\r
            Version::parse("  1.2.3  "),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: Vec::new(),\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3-alpha1"),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: Vec::new(),\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("  1.2.3-alpha1  "),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: Vec::new(),\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3+build5"),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("  1.2.3+build5  "),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3-alpha1+build5"),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("  1.2.3-alpha1+build5  "),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3-1.alpha1.9+build5.7.3aedf  "),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![\r
                    Identifier::Numeric(1),\r
                    Identifier::AlphaNumeric(String::from("alpha1")),\r
                    Identifier::Numeric(9),\r
                ],\r
                build: vec![\r
                    Identifier::AlphaNumeric(String::from("build5")),\r
                    Identifier::Numeric(7),\r
                    Identifier::AlphaNumeric(String::from("3aedf")),\r
                ],\r
            })\r
        );\r
        assert_eq!(\r
            Version::parse("0.4.0-beta.1+0851523"),\r
            Ok(Version {\r
                major: 0,\r
                minor: 4,\r
                patch: 0,\r
                pre: vec![\r
                    Identifier::AlphaNumeric(String::from("beta")),\r
                    Identifier::Numeric(1),\r
                ],\r
                build: vec![Identifier::AlphaNumeric(String::from("0851523"))],\r
            })\r
        );\r
    }\r
\r
    #[test]\r
    fn test_increment_patch() {\r
        let mut buggy_release = Version::parse("0.1.0").unwrap();\r
        buggy_release.increment_patch();\r
        assert_eq!(buggy_release, Version::parse("0.1.1").unwrap());\r
    }\r
\r
    #[test]\r
    fn test_increment_minor() {\r
        let mut feature_release = Version::parse("1.4.6").unwrap();\r
        feature_release.increment_minor();\r
        assert_eq!(feature_release, Version::parse("1.5.0").unwrap());\r
    }\r
\r
    #[test]\r
    fn test_increment_major() {\r
        let mut chrome_release = Version::parse("46.1.246773").unwrap();\r
        chrome_release.increment_major();\r
        assert_eq!(chrome_release, Version::parse("47.0.0").unwrap());\r
    }\r
\r
    #[test]\r
    fn test_increment_keep_prerelease() {\r
        let mut release = Version::parse("1.0.0-alpha").unwrap();\r
        release.increment_patch();\r
\r
        assert_eq!(release, Version::parse("1.0.1").unwrap());\r
\r
        release.increment_minor();\r
\r
        assert_eq!(release, Version::parse("1.1.0").unwrap());\r
\r
        release.increment_major();\r
\r
        assert_eq!(release, Version::parse("2.0.0").unwrap());\r
    }\r
\r
    #[test]\r
    fn test_increment_clear_metadata() {\r
        let mut release = Version::parse("1.0.0+4442").unwrap();\r
        release.increment_patch();\r
\r
        assert_eq!(release, Version::parse("1.0.1").unwrap());\r
        release = Version::parse("1.0.1+hello").unwrap();\r
\r
        release.increment_minor();\r
\r
        assert_eq!(release, Version::parse("1.1.0").unwrap());\r
        release = Version::parse("1.1.3747+hello").unwrap();\r
\r
        release.increment_major();\r
\r
        assert_eq!(release, Version::parse("2.0.0").unwrap());\r
    }\r
\r
    #[test]\r
    fn test_eq() {\r
        assert_eq!(Version::parse("1.2.3"), Version::parse("1.2.3"));\r
        assert_eq!(\r
            Version::parse("1.2.3-alpha1"),\r
            Version::parse("1.2.3-alpha1")\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3+build.42"),\r
            Version::parse("1.2.3+build.42")\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3-alpha1+42"),\r
            Version::parse("1.2.3-alpha1+42")\r
        );\r
        assert_eq!(Version::parse("1.2.3+23"), Version::parse("1.2.3+42"));\r
    }\r
\r
    #[test]\r
    fn test_ne() {\r
        assert!(Version::parse("0.0.0") != Version::parse("0.0.1"));\r
        assert!(Version::parse("0.0.0") != Version::parse("0.1.0"));\r
        assert!(Version::parse("0.0.0") != Version::parse("1.0.0"));\r
        assert!(Version::parse("1.2.3-alpha") != Version::parse("1.2.3-beta"));\r
    }\r
\r
    #[test]\r
    fn test_show() {\r
        assert_eq!(\r
            format!("{}", Version::parse("1.2.3").unwrap()),\r
            "1.2.3".to_string()\r
        );\r
        assert_eq!(\r
            format!("{}", Version::parse("1.2.3-alpha1").unwrap()),\r
            "1.2.3-alpha1".to_string()\r
        );\r
        assert_eq!(\r
            format!("{}", Version::parse("1.2.3+build.42").unwrap()),\r
            "1.2.3+build.42".to_string()\r
        );\r
        assert_eq!(\r
            format!("{}", Version::parse("1.2.3-alpha1+42").unwrap()),\r
            "1.2.3-alpha1+42".to_string()\r
        );\r
    }\r
\r
    #[test]\r
    fn test_display() {\r
        let version = Version::parse("1.2.3-rc1").unwrap();\r
        assert_eq!(format!("{:20}", version), "1.2.3-rc1           ");\r
        assert_eq!(format!("{:*^20}", version), "*****1.2.3-rc1******");\r
        assert_eq!(format!("{:.4}", version), "1.2.");\r
    }\r
\r
    #[test]\r
    fn test_to_string() {\r
        assert_eq!(\r
            Version::parse("1.2.3").unwrap().to_string(),\r
            "1.2.3".to_string()\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3-alpha1").unwrap().to_string(),\r
            "1.2.3-alpha1".to_string()\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3+build.42").unwrap().to_string(),\r
            "1.2.3+build.42".to_string()\r
        );\r
        assert_eq!(\r
            Version::parse("1.2.3-alpha1+42").unwrap().to_string(),\r
            "1.2.3-alpha1+42".to_string()\r
        );\r
    }\r
\r
    #[test]\r
    fn test_lt() {\r
        assert!(Version::parse("0.0.0") < Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.0.0") < Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.2.0") < Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.2.3-alpha1") < Version::parse("1.2.3"));\r
        assert!(Version::parse("1.2.3-alpha1") < Version::parse("1.2.3-alpha2"));\r
        assert!(!(Version::parse("1.2.3-alpha2") < Version::parse("1.2.3-alpha2")));\r
        assert!(!(Version::parse("1.2.3+23") < Version::parse("1.2.3+42")));\r
    }\r
\r
    #[test]\r
    fn test_le() {\r
        assert!(Version::parse("0.0.0") <= Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.0.0") <= Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.2.0") <= Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.2.3-alpha1") <= Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.2.3-alpha2") <= Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.2.3+23") <= Version::parse("1.2.3+42"));\r
    }\r
\r
    #[test]\r
    fn test_gt() {\r
        assert!(Version::parse("1.2.3-alpha2") > Version::parse("0.0.0"));\r
        assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.0.0"));\r
        assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.0"));\r
        assert!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.3-alpha1"));\r
        assert!(Version::parse("1.2.3") > Version::parse("1.2.3-alpha2"));\r
        assert!(!(Version::parse("1.2.3-alpha2") > Version::parse("1.2.3-alpha2")));\r
        assert!(!(Version::parse("1.2.3+23") > Version::parse("1.2.3+42")));\r
    }\r
\r
    #[test]\r
    fn test_ge() {\r
        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("0.0.0"));\r
        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.0.0"));\r
        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.0"));\r
        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.3-alpha1"));\r
        assert!(Version::parse("1.2.3-alpha2") >= Version::parse("1.2.3-alpha2"));\r
        assert!(Version::parse("1.2.3+23") >= Version::parse("1.2.3+42"));\r
    }\r
\r
    #[test]\r
    fn test_prerelease_check() {\r
        assert!(Version::parse("1.0.0").unwrap().is_prerelease() == false);\r
        assert!(Version::parse("0.0.1").unwrap().is_prerelease() == false);\r
        assert!(Version::parse("4.1.4-alpha").unwrap().is_prerelease());\r
        assert!(Version::parse("1.0.0-beta294296").unwrap().is_prerelease());\r
    }\r
\r
    #[test]\r
    fn test_spec_order() {\r
        let vs = [\r
            "1.0.0-alpha",\r
            "1.0.0-alpha.1",\r
            "1.0.0-alpha.beta",\r
            "1.0.0-beta",\r
            "1.0.0-beta.2",\r
            "1.0.0-beta.11",\r
            "1.0.0-rc.1",\r
            "1.0.0",\r
        ];\r
        let mut i = 1;\r
        while i < vs.len() {\r
            let a = Version::parse(vs[i - 1]);\r
            let b = Version::parse(vs[i]);\r
            assert!(a < b, "nope {:?} < {:?}", a, b);\r
            i += 1;\r
        }\r
    }\r
\r
    #[test]\r
    fn test_from_str() {\r
        assert_eq!(\r
            "1.2.3".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: Vec::new(),\r
            })\r
        );\r
        assert_eq!(\r
            "  1.2.3  ".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: Vec::new(),\r
            })\r
        );\r
        assert_eq!(\r
            "1.2.3-alpha1".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: Vec::new(),\r
            })\r
        );\r
        assert_eq!(\r
            "  1.2.3-alpha1  ".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: Vec::new(),\r
            })\r
        );\r
        assert_eq!(\r
            "1.2.3+build5".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            "  1.2.3+build5  ".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: Vec::new(),\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            "1.2.3-alpha1+build5".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            "  1.2.3-alpha1+build5  ".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![Identifier::AlphaNumeric(String::from("alpha1"))],\r
                build: vec![Identifier::AlphaNumeric(String::from("build5"))],\r
            })\r
        );\r
        assert_eq!(\r
            "1.2.3-1.alpha1.9+build5.7.3aedf  ".parse(),\r
            Ok(Version {\r
                major: 1,\r
                minor: 2,\r
                patch: 3,\r
                pre: vec![\r
                    Identifier::Numeric(1),\r
                    Identifier::AlphaNumeric(String::from("alpha1")),\r
                    Identifier::Numeric(9),\r
                ],\r
                build: vec![\r
                    Identifier::AlphaNumeric(String::from("build5")),\r
                    Identifier::Numeric(7),\r
                    Identifier::AlphaNumeric(String::from("3aedf")),\r
                ],\r
            })\r
        );\r
        assert_eq!(\r
            "0.4.0-beta.1+0851523".parse(),\r
            Ok(Version {\r
                major: 0,\r
                minor: 4,\r
                patch: 0,\r
                pre: vec![\r
                    Identifier::AlphaNumeric(String::from("beta")),\r
                    Identifier::Numeric(1),\r
                ],\r
                build: vec![Identifier::AlphaNumeric(String::from("0851523"))],\r
            })\r
        );\r
    }\r
\r
    #[test]\r
    fn test_from_str_errors() {\r
        fn parse_error(e: &str) -> result::Result<Version, SemVerError> {\r
            return Err(SemVerError::ParseError(e.to_string()));\r
        }\r
\r
        assert_eq!("".parse(), parse_error("Error parsing major identifier"));\r
        assert_eq!("  ".parse(), parse_error("Error parsing major identifier"));\r
        assert_eq!("1".parse(), parse_error("Expected dot"));\r
        assert_eq!("1.2".parse(), parse_error("Expected dot"));\r
        assert_eq!("1.2.3-".parse(), parse_error("Error parsing prerelease"));\r
        assert_eq!(\r
            "a.b.c".parse(),\r
            parse_error("Error parsing major identifier")\r
        );\r
        assert_eq!(\r
            "1.2.3 abc".parse(),\r
            parse_error("Extra junk after valid version:  abc")\r
        );\r
    }\r
}\r