android/vendor/tame-index-0.10.0/src/krate_name.rs - toolchain/cargo-deny - Git at Google

 use crate::error::{Error, InvalidKrateName};

 #[cfg(test)]
 #[macro_export]
 macro_rules! kn {
     ($kn:literal) => {
         $crate::KrateName($kn)
     };
 }

 /// Used to wrap user-provided strings so that bad crate names are required to
 /// be handled separately from things more outside the user control such as I/O
 /// errors
 #[derive(Copy, Clone)]
 pub struct KrateName<'name>(pub(crate) &'name str);

 impl<'name> KrateName<'name> {
     /// Ensures the specified string is a valid crates.io crate name, according
     /// to the (current) crates.io name restrictions
     ///
     /// 1. Non-empty
     /// 2. May not start with a digit
     /// 3. Maximum of 64 characters in length
     /// 4. Must be ASCII alphanumeric, `-`, or `_`
     /// 5. May not be a reserved name
     ///     * A Rust keyword
     ///     * Name of a Cargo output artifact
     ///     * Name of a std library crate (or `test`)
     ///     * A reserved Windows name (such as `nul`)
     #[inline]
     pub fn crates_io(name: &'name str) -> Result<Self, Error> {
         Self::validated(name, Some(64))
     }

     /// Ensures the specified string is a valid crate name according to [cargo](https://github.com/rust-lang/cargo/blob/00b8da63269420610758464c02fc46584e373dd3/src/cargo/ops/cargo_new.rs#L167-L264)
     ///
     /// 1. Non-empty
     /// 2. May not start with a digit
     /// 3. Must be ASCII alphanumeric, `-`, or `_`
     /// 4. May not be a reserved name
     ///     * A Rust keyword
     ///     * Name of a Cargo output artifact
     ///     * Name of a std library crate (or `test`)
     ///     * A reserved Windows name (such as `nul`)
     #[inline]
     pub fn cargo(name: &'name str) -> Result<Self, Error> {
         Self::validated(name, None)
     }

     fn validated(name: &'name str, max_len: Option<usize>) -> Result<Self, Error> {
         if name.is_empty() {
             return Err(InvalidKrateName::InvalidLength(0).into());
         }

         let mut chars = name.chars().enumerate();

         while let Some((i, c)) = chars.next() {
             if i == 0 && c != '_' && !c.is_ascii_alphabetic() {
                 return Err(InvalidKrateName::InvalidCharacter {
                     invalid: c,
                     index: i,
                 }
                 .into());
             }

             if max_len == Some(i) {
                 return Err(InvalidKrateName::InvalidLength(i + 1 + chars.count()).into());
             }

             if c != '-' && c != '_' && !c.is_ascii_alphanumeric() {
                 return Err(InvalidKrateName::InvalidCharacter {
                     invalid: c,
                     index: i,
                 }
                 .into());
             }
         }

         // This is a single table, binary sorted so that we can more easily just
         // check matches and move on
         //
         // 1. Rustlang keywords, see https://doc.rust-lang.org/reference/keywords.html
         // 2. Windows reserved, see https://github.com/rust-lang/cargo/blob/b40be8bdcf2eff9ed81702594d44bf96c27973a6/src/cargo/util/restricted_names.rs#L26-L32
         // 3. Cargo artifacts, see https://github.com/rust-lang/cargo/blob/b40be8bdcf2eff9ed81702594d44bf96c27973a6/src/cargo/util/restricted_names.rs#L35-L37
         // 4. Rustlang std, see https://github.com/rust-lang/cargo/blob/b40be8bdcf2eff9ed81702594d44bf96c27973a6/src/cargo/ops/cargo_new.rs#L225-L239
         use crate::error::ReservedNameKind::{Artifact, Keyword, Standard, Windows};
         const DISALLOWED: &[(&str, crate::error::ReservedNameKind)] = &[
             ("Self", Keyword),
             ("abstract", Keyword),
             ("alloc", Standard),
             ("as", Keyword),
             ("async", Keyword),
             ("aux", Windows),
             ("await", Keyword),
             ("become", Keyword),
             ("box", Keyword),
             ("break", Keyword),
             ("build", Artifact),
             ("com1", Windows),
             ("com2", Windows),
             ("com3", Windows),
             ("com4", Windows),
             ("com5", Windows),
             ("com6", Windows),
             ("com7", Windows),
             ("com8", Windows),
             ("com9", Windows),
             ("con", Windows),
             ("const", Keyword),
             ("continue", Keyword),
             ("core", Standard),
             ("crate", Keyword),
             ("deps", Artifact),
             ("do", Keyword),
             ("dyn", Keyword),
             ("else", Keyword),
             ("enum", Keyword),
             ("examples", Artifact),
             ("extern", Keyword),
             ("false", Keyword),
             ("final", Keyword),
             ("fn", Keyword),
             ("for", Keyword),
             ("if", Keyword),
             ("impl", Keyword),
             ("in", Keyword),
             ("incremental", Artifact),
             ("let", Keyword),
             ("loop", Keyword),
             ("lpt1", Windows),
             ("lpt2", Windows),
             ("lpt3", Windows),
             ("lpt4", Windows),
             ("lpt5", Windows),
             ("lpt6", Windows),
             ("lpt7", Windows),
             ("lpt8", Windows),
             ("lpt9", Windows),
             ("macro", Keyword),
             ("match", Keyword),
             ("mod", Keyword),
             ("move", Keyword),
             ("mut", Keyword),
             ("nul", Windows),
             ("override", Keyword),
             ("priv", Keyword),
             ("proc-macro", Standard),
             ("proc_macro", Standard),
             ("prn", Windows),
             ("pub", Keyword),
             ("ref", Keyword),
             ("return", Keyword),
             ("self", Keyword),
             ("static", Keyword),
             ("std", Standard),
             ("struct", Keyword),
             ("super", Keyword),
             ("test", Standard),
             ("trait", Keyword),
             ("true", Keyword),
             ("try", Keyword),
             ("type", Keyword),
             ("typeof", Keyword),
             ("unsafe", Keyword),
             ("unsized", Keyword),
             ("use", Keyword),
             ("virtual", Keyword),
             ("where", Keyword),
             ("while", Keyword),
             ("yield", Keyword),
         ];

         if let Ok(i) = DISALLOWED.binary_search_by_key(&name, |(k, _v)| k) {
             let (reserved, kind) = DISALLOWED[i];
             Err(InvalidKrateName::ReservedName { reserved, kind }.into())
         } else {
             Ok(Self(name))
         }
     }
 }

 /// The simplest way to create a crate name, this just ensures that the crate name
 /// is non-empty, and ASCII alphanumeric, `-`, or, `-`, the minimum requirements
 /// for this crate
 impl<'name> TryFrom<&'name str> for KrateName<'name> {
     type Error = Error;
     #[inline]
     fn try_from(s: &'name str) -> Result<Self, Self::Error> {
         if s.is_empty() {
             Err(InvalidKrateName::InvalidLength(0).into())
         } else if let Some((index, invalid)) = s
             .chars()
             .enumerate()
             .find(|(_i, c)| *c != '-' && *c != '_' && !c.is_ascii_alphanumeric())
         {
             Err(InvalidKrateName::InvalidCharacter { invalid, index }.into())
         } else {
             Ok(Self(s))
         }
     }
 }

 impl<'name> KrateName<'name> {
     /// Writes the crate's prefix to the specified string
     ///
     /// Cargo uses a simple prefix in the registry index so that crate's can be
     /// partitioned, particularly on disk without running up against potential OS
     /// specific issues when hundreds of thousands of files are located with a single
     /// directory
     ///
     /// The separator should be [`std::path::MAIN_SEPARATOR`] in disk cases and
     /// '/' when used for urls
     pub fn prefix(&self, acc: &mut String, sep: char) {
         let name = self.0;
         match name.len() {
             0 => unreachable!(),
             1 => acc.push('1'),
             2 => acc.push('2'),
             3 => {
                 acc.push('3');
                 acc.push(sep);
                 acc.push_str(&name[..1]);
             }
             _ => {
                 acc.push_str(&name[..2]);
                 acc.push(sep);
                 acc.push_str(&name[2..4]);
             }
         }
     }

     /// Gets the relative path to a crate
     ///
     /// This will be of the form [`Self::prefix`] + `<sep>` + `<name>`
     ///
     /// If not specified, the separator is [`std::path::MAIN_SEPARATOR`]
     ///
     /// ```
     /// let crate_name: tame_index::KrateName = "tame-index".try_into().unwrap();
     /// assert_eq!(crate_name.relative_path(Some('/')), "ta/me/tame-index");
     /// ```
     pub fn relative_path(&self, sep: Option<char>) -> String {
         let name = self.0;
         // Preallocate with the maximum possible width of a crate prefix `aa/bb/`
         let mut rel_path = String::with_capacity(name.len() + 6);
         let sep = sep.unwrap_or(std::path::MAIN_SEPARATOR);

         self.prefix(&mut rel_path, sep);
         rel_path.push(sep);
         rel_path.push_str(name);

         // A valid krate name is ASCII only, we don't need to worry about
         // lowercasing utf-8
         rel_path.make_ascii_lowercase();

         rel_path
     }
 }

 use std::fmt;

 impl<'k> fmt::Display for KrateName<'k> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(self.0)
     }
 }

 impl<'k> fmt::Debug for KrateName<'k> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(self.0)
     }
 }

 #[cfg(test)]
 mod test {
     use super::KrateName;
     use crate::error::{Error, InvalidKrateName, ReservedNameKind};

     /// Validates that all ways to create a krate name validate the basics of
     /// not empty and allowed characters
     #[test]
     fn rejects_simple() {
         assert!(matches!(
             TryInto::<KrateName<'_>>::try_into("").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::InvalidLength(0))
         ));
         assert!(matches!(
             KrateName::crates_io("").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::InvalidLength(0))
         ));
         assert!(matches!(
             TryInto::<KrateName<'_>>::try_into("no.pe").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::InvalidCharacter {
                 index: 2,
                 invalid: '.',
             })
         ));
         assert!(matches!(
             KrateName::crates_io("no.pe").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::InvalidCharacter {
                 index: 2,
                 invalid: '.',
             })
         ));
     }

     /// Validates that crate names can't start with digit
     #[test]
     fn rejects_leading_digit() {
         assert!(matches!(
             KrateName::crates_io("3nop").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::InvalidCharacter {
                 index: 0,
                 invalid: '3',
             })
         ));
     }

     /// Validates the crate name doesn't exceed the crates.io limit
     #[test]
     fn rejects_too_long() {
         assert!(matches!(
             KrateName::crates_io(
                 "aaaaaaaabbbbbbbbccccccccddddddddaaaaaaaabbbbbbbbccccccccddddddddxxxxxxx"
             )
             .unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::InvalidLength(71))
         ));

         assert!(KrateName::cargo(
             "aaaaaaaabbbbbbbbccccccccddddddddaaaaaaaabbbbbbbbccccccccddddddddxxxxxxx"
         )
         .is_ok());
     }

     /// Validates the crate name can't be a reserved name
     #[test]
     fn rejects_reserved() {
         assert!(matches!(
             KrateName::cargo("nul").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::ReservedName {
                 reserved: "nul",
                 kind: ReservedNameKind::Windows
             })
         ));
         assert!(matches!(
             KrateName::cargo("deps").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::ReservedName {
                 reserved: "deps",
                 kind: ReservedNameKind::Artifact
             })
         ));
         assert!(matches!(
             KrateName::cargo("Self").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::ReservedName {
                 reserved: "Self",
                 kind: ReservedNameKind::Keyword
             })
         ));
         assert!(matches!(
             KrateName::cargo("yield").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::ReservedName {
                 reserved: "yield",
                 kind: ReservedNameKind::Keyword
             })
         ));
         assert!(matches!(
             KrateName::cargo("proc-macro").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::ReservedName {
                 reserved: "proc-macro",
                 kind: ReservedNameKind::Standard
             })
         ));
         assert!(matches!(
             KrateName::cargo("proc_macro").unwrap_err(),
             Error::InvalidKrateName(InvalidKrateName::ReservedName {
                 reserved: "proc_macro",
                 kind: ReservedNameKind::Standard
             })
         ));
     }

     #[inline]
     fn rp(n: &str) -> String {
         KrateName(n).relative_path(Some('/'))
     }

     /// Validates we get the correct relative path to crate
     #[test]
     fn relative_path() {
         assert_eq!(rp("a"), "1/a");
         assert_eq!(rp("ab"), "2/ab");
         assert_eq!(rp("abc"), "3/a/abc");
         assert_eq!(rp("AbCd"), "ab/cd/abcd");
         assert_eq!(rp("normal"), "no/rm/normal");
         assert_eq!(rp("_boop-"), "_b/oo/_boop-");
         assert_eq!(rp("Inflector"), "in/fl/inflector");
     }
 }
	use crate::error::{Error, InvalidKrateName};

	#[cfg(test)]
	#[macro_export]
	macro_rules! kn {
	($kn:literal) => {
	$crate::KrateName($kn)
	};
	}

	/// Used to wrap user-provided strings so that bad crate names are required to
	/// be handled separately from things more outside the user control such as I/O
	/// errors
	#[derive(Copy, Clone)]
	pub struct KrateName<'name>(pub(crate) &'name str);

	impl<'name> KrateName<'name> {
	/// Ensures the specified string is a valid crates.io crate name, according
	/// to the (current) crates.io name restrictions
	///
	/// 1. Non-empty
	/// 2. May not start with a digit
	/// 3. Maximum of 64 characters in length
	/// 4. Must be ASCII alphanumeric, `-`, or `_`
	/// 5. May not be a reserved name
	/// * A Rust keyword
	/// * Name of a Cargo output artifact
	/// * Name of a std library crate (or `test`)
	/// * A reserved Windows name (such as `nul`)
	#[inline]
	pub fn crates_io(name: &'name str) -> Result<Self, Error> {
	Self::validated(name, Some(64))
	}

	/// Ensures the specified string is a valid crate name according to [cargo](https://github.com/rust-lang/cargo/blob/00b8da63269420610758464c02fc46584e373dd3/src/cargo/ops/cargo_new.rs#L167-L264)
	///
	/// 1. Non-empty
	/// 2. May not start with a digit
	/// 3. Must be ASCII alphanumeric, `-`, or `_`
	/// 4. May not be a reserved name
	/// * A Rust keyword
	/// * Name of a Cargo output artifact
	/// * Name of a std library crate (or `test`)
	/// * A reserved Windows name (such as `nul`)
	#[inline]
	pub fn cargo(name: &'name str) -> Result<Self, Error> {
	Self::validated(name, None)
	}

	fn validated(name: &'name str, max_len: Option<usize>) -> Result<Self, Error> {
	if name.is_empty() {
	return Err(InvalidKrateName::InvalidLength(0).into());
	}

	let mut chars = name.chars().enumerate();

	while let Some((i, c)) = chars.next() {
	if i == 0 && c != '_' && !c.is_ascii_alphabetic() {
	return Err(InvalidKrateName::InvalidCharacter {
	invalid: c,
	index: i,
	}
	.into());
	}

	if max_len == Some(i) {
	return Err(InvalidKrateName::InvalidLength(i + 1 + chars.count()).into());
	}

	if c != '-' && c != '_' && !c.is_ascii_alphanumeric() {
	return Err(InvalidKrateName::InvalidCharacter {
	invalid: c,
	index: i,
	}
	.into());
	}
	}

	// This is a single table, binary sorted so that we can more easily just
	// check matches and move on
	//
	// 1. Rustlang keywords, see https://doc.rust-lang.org/reference/keywords.html
	// 2. Windows reserved, see https://github.com/rust-lang/cargo/blob/b40be8bdcf2eff9ed81702594d44bf96c27973a6/src/cargo/util/restricted_names.rs#L26-L32
	// 3. Cargo artifacts, see https://github.com/rust-lang/cargo/blob/b40be8bdcf2eff9ed81702594d44bf96c27973a6/src/cargo/util/restricted_names.rs#L35-L37
	// 4. Rustlang std, see https://github.com/rust-lang/cargo/blob/b40be8bdcf2eff9ed81702594d44bf96c27973a6/src/cargo/ops/cargo_new.rs#L225-L239
	use crate::error::ReservedNameKind::{Artifact, Keyword, Standard, Windows};
	const DISALLOWED: &[(&str, crate::error::ReservedNameKind)] = &[
	("Self", Keyword),
	("abstract", Keyword),
	("alloc", Standard),
	("as", Keyword),
	("async", Keyword),
	("aux", Windows),
	("await", Keyword),
	("become", Keyword),
	("box", Keyword),
	("break", Keyword),
	("build", Artifact),
	("com1", Windows),
	("com2", Windows),
	("com3", Windows),
	("com4", Windows),
	("com5", Windows),
	("com6", Windows),
	("com7", Windows),
	("com8", Windows),
	("com9", Windows),
	("con", Windows),
	("const", Keyword),
	("continue", Keyword),
	("core", Standard),
	("crate", Keyword),
	("deps", Artifact),
	("do", Keyword),
	("dyn", Keyword),
	("else", Keyword),
	("enum", Keyword),
	("examples", Artifact),
	("extern", Keyword),
	("false", Keyword),
	("final", Keyword),
	("fn", Keyword),
	("for", Keyword),
	("if", Keyword),
	("impl", Keyword),
	("in", Keyword),
	("incremental", Artifact),
	("let", Keyword),
	("loop", Keyword),
	("lpt1", Windows),
	("lpt2", Windows),
	("lpt3", Windows),
	("lpt4", Windows),
	("lpt5", Windows),
	("lpt6", Windows),
	("lpt7", Windows),
	("lpt8", Windows),
	("lpt9", Windows),
	("macro", Keyword),
	("match", Keyword),
	("mod", Keyword),
	("move", Keyword),
	("mut", Keyword),
	("nul", Windows),
	("override", Keyword),
	("priv", Keyword),
	("proc-macro", Standard),
	("proc_macro", Standard),
	("prn", Windows),
	("pub", Keyword),
	("ref", Keyword),
	("return", Keyword),
	("self", Keyword),
	("static", Keyword),
	("std", Standard),
	("struct", Keyword),
	("super", Keyword),
	("test", Standard),
	("trait", Keyword),
	("true", Keyword),
	("try", Keyword),
	("type", Keyword),
	("typeof", Keyword),
	("unsafe", Keyword),
	("unsized", Keyword),
	("use", Keyword),
	("virtual", Keyword),
	("where", Keyword),
	("while", Keyword),
	("yield", Keyword),
	];

	if let Ok(i) = DISALLOWED.binary_search_by_key(&name, \|(k, _v)\| k) {
	let (reserved, kind) = DISALLOWED[i];
	Err(InvalidKrateName::ReservedName { reserved, kind }.into())
	} else {
	Ok(Self(name))
	}
	}
	}

	/// The simplest way to create a crate name, this just ensures that the crate name
	/// is non-empty, and ASCII alphanumeric, `-`, or, `-`, the minimum requirements
	/// for this crate
	impl<'name> TryFrom<&'name str> for KrateName<'name> {
	type Error = Error;
	#[inline]
	fn try_from(s: &'name str) -> Result<Self, Self::Error> {
	if s.is_empty() {
	Err(InvalidKrateName::InvalidLength(0).into())
	} else if let Some((index, invalid)) = s
	.chars()
	.enumerate()
	.find(\|(_i, c)\| c != '-' && c != '_' && !c.is_ascii_alphanumeric())
	{
	Err(InvalidKrateName::InvalidCharacter { invalid, index }.into())
	} else {
	Ok(Self(s))
	}
	}
	}

	impl<'name> KrateName<'name> {
	/// Writes the crate's prefix to the specified string
	///
	/// Cargo uses a simple prefix in the registry index so that crate's can be
	/// partitioned, particularly on disk without running up against potential OS
	/// specific issues when hundreds of thousands of files are located with a single
	/// directory
	///
	/// The separator should be [`std::path::MAIN_SEPARATOR`] in disk cases and
	/// '/' when used for urls
	pub fn prefix(&self, acc: &mut String, sep: char) {
	let name = self.0;
	match name.len() {
	0 => unreachable!(),
	1 => acc.push('1'),
	2 => acc.push('2'),
	3 => {
	acc.push('3');
	acc.push(sep);
	acc.push_str(&name[..1]);
	}
	_ => {
	acc.push_str(&name[..2]);
	acc.push(sep);
	acc.push_str(&name[2..4]);
	}
	}
	}

	/// Gets the relative path to a crate
	///
	/// This will be of the form [`Self::prefix`] + `<sep>` + `<name>`
	///
	/// If not specified, the separator is [`std::path::MAIN_SEPARATOR`]
	///
	/// ```
	/// let crate_name: tame_index::KrateName = "tame-index".try_into().unwrap();
	/// assert_eq!(crate_name.relative_path(Some('/')), "ta/me/tame-index");
	/// ```
	pub fn relative_path(&self, sep: Option<char>) -> String {
	let name = self.0;
	// Preallocate with the maximum possible width of a crate prefix `aa/bb/`
	let mut rel_path = String::with_capacity(name.len() + 6);
	let sep = sep.unwrap_or(std::path::MAIN_SEPARATOR);

	self.prefix(&mut rel_path, sep);
	rel_path.push(sep);
	rel_path.push_str(name);

	// A valid krate name is ASCII only, we don't need to worry about
	// lowercasing utf-8
	rel_path.make_ascii_lowercase();

	rel_path
	}
	}

	use std::fmt;

	impl<'k> fmt::Display for KrateName<'k> {
	#[inline]
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.write_str(self.0)
	}
	}

	impl<'k> fmt::Debug for KrateName<'k> {
	#[inline]
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.write_str(self.0)
	}
	}

	#[cfg(test)]
	mod test {
	use super::KrateName;
	use crate::error::{Error, InvalidKrateName, ReservedNameKind};

	/// Validates that all ways to create a krate name validate the basics of
	/// not empty and allowed characters
	#[test]
	fn rejects_simple() {
	assert!(matches!(
	TryInto::<KrateName<'_>>::try_into("").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::InvalidLength(0))
	));
	assert!(matches!(
	KrateName::crates_io("").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::InvalidLength(0))
	));
	assert!(matches!(
	TryInto::<KrateName<'_>>::try_into("no.pe").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::InvalidCharacter {
	index: 2,
	invalid: '.',
	})
	));
	assert!(matches!(
	KrateName::crates_io("no.pe").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::InvalidCharacter {
	index: 2,
	invalid: '.',
	})
	));
	}

	/// Validates that crate names can't start with digit
	#[test]
	fn rejects_leading_digit() {
	assert!(matches!(
	KrateName::crates_io("3nop").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::InvalidCharacter {
	index: 0,
	invalid: '3',
	})
	));
	}

	/// Validates the crate name doesn't exceed the crates.io limit
	#[test]
	fn rejects_too_long() {
	assert!(matches!(
	KrateName::crates_io(
	"aaaaaaaabbbbbbbbccccccccddddddddaaaaaaaabbbbbbbbccccccccddddddddxxxxxxx"
	)
	.unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::InvalidLength(71))
	));

	assert!(KrateName::cargo(
	"aaaaaaaabbbbbbbbccccccccddddddddaaaaaaaabbbbbbbbccccccccddddddddxxxxxxx"
	)
	.is_ok());
	}

	/// Validates the crate name can't be a reserved name
	#[test]
	fn rejects_reserved() {
	assert!(matches!(
	KrateName::cargo("nul").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::ReservedName {
	reserved: "nul",
	kind: ReservedNameKind::Windows
	})
	));
	assert!(matches!(
	KrateName::cargo("deps").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::ReservedName {
	reserved: "deps",
	kind: ReservedNameKind::Artifact
	})
	));
	assert!(matches!(
	KrateName::cargo("Self").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::ReservedName {
	reserved: "Self",
	kind: ReservedNameKind::Keyword
	})
	));
	assert!(matches!(
	KrateName::cargo("yield").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::ReservedName {
	reserved: "yield",
	kind: ReservedNameKind::Keyword
	})
	));
	assert!(matches!(
	KrateName::cargo("proc-macro").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::ReservedName {
	reserved: "proc-macro",
	kind: ReservedNameKind::Standard
	})
	));
	assert!(matches!(
	KrateName::cargo("proc_macro").unwrap_err(),
	Error::InvalidKrateName(InvalidKrateName::ReservedName {
	reserved: "proc_macro",
	kind: ReservedNameKind::Standard
	})
	));
	}

	#[inline]
	fn rp(n: &str) -> String {
	KrateName(n).relative_path(Some('/'))
	}

	/// Validates we get the correct relative path to crate
	#[test]
	fn relative_path() {
	assert_eq!(rp("a"), "1/a");
	assert_eq!(rp("ab"), "2/ab");
	assert_eq!(rp("abc"), "3/a/abc");
	assert_eq!(rp("AbCd"), "ab/cd/abcd");
	assert_eq!(rp("normal"), "no/rm/normal");
	assert_eq!(rp("_boop-"), "_b/oo/_boop-");
	assert_eq!(rp("Inflector"), "in/fl/inflector");
	}
	}