use super::{
DependenciesErr, FeatureDependenciesErr, Features, FeaturesErr, ImpliedFeaturesErr, Manifest,
ManifestErr, Msrv, NonZeroUsizePlus1, Package, PackageErr, Path, PathBuf, PowerSet,
TooManyFeaturesErr, TryLockError, WorkspaceErr,
};
impl PartialEq for PackageErr {
#[expect(clippy::cognitive_complexity, reason = "long match expression")]
fn eq(&self, other: &Self) -> bool {
match *self {
Self::Missing => matches!(*other, Self::Missing),
Self::InvalidType => matches!(*other, Self::InvalidType),
Self::MissingName => matches!(*other, Self::MissingName),
Self::InvalidNameType => matches!(*other, Self::InvalidNameType),
Self::InvalidMsrvType => matches!(*other, Self::InvalidMsrvType),
Self::Msrv => matches!(*other, Self::Msrv),
Self::MsrvWorkspaceMissing => matches!(*other, Self::MsrvWorkspaceMissing),
Self::MsrvWorkspaceVal => matches!(*other, Self::MsrvWorkspaceVal),
Self::InvalidWorkspaceType => matches!(*other, Self::InvalidWorkspaceType),
Self::WorkspaceIo(ref e) => {
matches!(*other, Self::WorkspaceIo(ref e2) if e.kind() == e2.kind())
}
Self::WorkspaceLock(ref e) => {
matches!(*other, Self::WorkspaceLock(ref e2) if match *e {
TryLockError::Error(ref inner_e) => matches!(*e2, TryLockError::Error(ref inner_e2) if inner_e.kind() == inner_e2.kind()),
TryLockError::WouldBlock => matches!(*e2, TryLockError::WouldBlock),
})
}
Self::WorkspaceLenMismatch => matches!(*other, Self::WorkspaceLenMismatch),
Self::WorkspaceDoesNotExist => matches!(*other, Self::WorkspaceDoesNotExist),
Self::WorkspaceRead(ref e, ref p) => {
matches!(*other, Self::WorkspaceRead(ref e2, ref p2) if e.kind() == e2.kind() && p == p2)
}
Self::WorkspaceReadLock(ref e, ref p) => {
matches!(*other, Self::WorkspaceReadLock(ref e2, ref p2) if p == p2 && match *e {
TryLockError::Error(ref inner_e) => matches!(*e2, TryLockError::Error(ref inner_e2) if inner_e.kind() == inner_e2.kind()),
TryLockError::WouldBlock => matches!(*e2, TryLockError::WouldBlock),
})
}
Self::WorkspaceReadLenMismatch(ref p) => {
matches!(*other, Self::WorkspaceReadLenMismatch(ref p2) if p == p2)
}
Self::WorkspaceToml(ref e, ref p) => {
matches!(*other, Self::WorkspaceToml(ref e2, ref p2) if e == e2 && p == p2)
}
Self::Workspace(e, ref p) => {
matches!(*other, Self::Workspace(e2, ref p2) if e == e2 && p == p2)
}
}
}
}
#[expect(
clippy::cognitive_complexity,
clippy::too_many_lines,
reason = "want to test a lot of things"
)]
#[test]
fn cargo_toml() {
assert!(
Manifest::from_toml("a".to_owned(), false, Path::new(""), &[])
.map_or_else(|e| matches!(*e, ManifestErr::Toml(_, _)), |_| false)
);
assert_eq!(
Manifest::from_toml(String::new(), false, Path::new(""), &[]),
Err(Box::new(ManifestErr::Package(
PackageErr::Missing,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml("[' package']".to_owned(), false, Path::new(""), &[]),
Err(Box::new(ManifestErr::Package(
PackageErr::Missing,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml("['package ']".to_owned(), false, Path::new(""), &[]),
Err(Box::new(ManifestErr::Package(
PackageErr::Missing,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml("package=2".to_owned(), false, Path::new(""), &[]),
Err(Box::new(ManifestErr::Package(
PackageErr::InvalidType,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml("[package]".to_owned(), false, Path::new(""), &[]),
Err(Box::new(ManifestErr::Package(
PackageErr::MissingName,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml("[package]\nname=true".to_owned(), false, Path::new(""), &[]),
Err(Box::new(ManifestErr::Package(
PackageErr::InvalidNameType,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\n\nrust-version=2".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::InvalidMsrvType,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"a\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"1.00.0\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"1..0\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"1.\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"01.0.0\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"1.0.0.1\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"111111111111111111111111.2.3\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"1.0.0-nightly\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"-1.0.0\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\" 1.0.0\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"1.0.0 \"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Msrv,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version={}".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::MsrvWorkspaceMissing,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version={workspace=2}".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::MsrvWorkspaceVal,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version={workspace=false}".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::MsrvWorkspaceVal,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version={workspace=true}\nworkspace=2".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::InvalidWorkspaceType,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"workspace=2\n[package]\nname=\"\"\nrust-version={workspace=true}".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Workspace(WorkspaceErr::InvalidType, PathBuf::new()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[workspace]\n[package]\nname=\"\"\nrust-version={workspace=true}".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Workspace(WorkspaceErr::MissingPackage, PathBuf::new()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[workspace]\npackage=2\n[package]\nname=\"\"\nrust-version={workspace=true}"
.to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Workspace(WorkspaceErr::InvalidPackageType, PathBuf::new()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[workspace.package]\n[package]\nname=\"\"\nrust-version={workspace=true}".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Workspace(WorkspaceErr::MissingPackageMsrv, PathBuf::new()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[workspace.package]\nrust-version={}\n[package]\nname=\"\"\nrust-version={workspace=true}"
.to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Workspace(WorkspaceErr::InvalidPackageMsrvType, PathBuf::new()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[workspace.package]\nrust-version=\"\"\n[package]\nname=\"\"\nrust-version={workspace=true}"
.to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Package(
PackageErr::Workspace(WorkspaceErr::Msrv, PathBuf::new()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"features=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::InvalidType,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"/\"=[]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::InvalidName("/".to_owned()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"dep:\"=[]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::InvalidName("dep:".to_owned()),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidFeatureType(
String::new()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[true]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependencyType(
String::new()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependency(
String::new(),
"foo".to_owned()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[dependencies]\nfoo={optional=true}\n[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\""
.to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependency(
String::new(),
"foo".to_owned()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"\"]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature(String::new())),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"a\"]\na=[\"\"]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature(String::new())),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"a\"]\na=[\"b\"]\nb=[\"a\"]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature("a".to_owned())),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"a\"]\na=[\"c\",\"b\"]\nb=[\"a\"]\nc=[]\n[package]\nname=\"\""
.to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature("a".to_owned())),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[]\na=[\"c\",\"b\"]\nb=[\"a\"]\nc=[]\n[package]\nname=\"\""
.to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature("a".to_owned())),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"a\",\"b\"]\na=[\"b\"]\nb=[]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::RedundantDependency(
String::new(),
"b".to_owned()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"a\",\"a\"]\na=[]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::RedundantDependency(
String::new(),
"a".to_owned()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"dep:\",\"dep:\"]\na=[]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::RedundantDependency(
String::new(),
"dep:".to_owned()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"target=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TargetType,
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"dependencies=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::Type("dependencies")),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"build-dependencies=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::Type("build-dependencies")),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::Name(
"dependencies",
"dep:".to_owned()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::Name("dependencies", "/".to_owned())),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[build-dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::Name(
"build-dependencies",
"dep:".to_owned()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[build-dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::Name(
"build-dependencies",
"/".to_owned()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[dependencies]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::DependencyType(
"dependencies",
String::new()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[build-dependencies]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::DependencyType(
"build-dependencies",
String::new()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[dependencies]\n\"\"={optional=2}\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::OptionalType(
"dependencies",
String::new()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[build-dependencies]\n\"\"={optional=2}\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::OptionalType(
"build-dependencies",
String::new()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[dependencies]\nfoo={optional=true}\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::Dependencies(DependenciesErr::ImpliedFeature(
"dependencies",
"foo".to_owned()
)),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TargetPlatformType(String::new()),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\"]\ndependencies=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::Type("dependencies")
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\"]\nbuild-dependencies=2\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::Type("build-dependencies")
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::Name("dependencies", "/".to_owned())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::Name("dependencies", "dep:".to_owned())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".build-dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::Name("build-dependencies", "/".to_owned())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".build-dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::Name("build-dependencies", "dep:".to_owned())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".dependencies]\n\"\"=false\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::DependencyType("dependencies", String::new())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".build-dependencies]\n\"\"=false\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::DependencyType("build-dependencies", String::new())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".dependencies]\n\"\"={optional=2}\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::OptionalType("dependencies", String::new())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[target.\"\".build-dependencies]\n\"\"={optional=2}\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::TagetPlatformDependencies(
String::new(),
DependenciesErr::OptionalType("build-dependencies", String::new())
),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\"".to_owned(),
true,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::ImpliedFeatures(
ImpliedFeaturesErr::InvalidDependency(String::new(), "foo".to_owned()),
PathBuf::new(),
)))
);
assert_eq!(
Manifest::from_toml(
"[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&[]
),
Err(Box::new(ManifestErr::Features(
FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependency(
String::new(),
"foo".to_owned()
)),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"".to_owned(),
false,
Path::new(""),
&["a".to_owned()]
),
Err(Box::new(ManifestErr::UndefinedIgnoreFeature(
"a".to_owned(),
PathBuf::new()
)))
);
assert_eq!(
Manifest::from_toml(
"[dependencies]\nfoo={optional=true}\n[features]\nfoo=[]\n[package]\nname=\"\""
.to_owned(),
false,
Path::new(""),
&[]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![("foo".to_owned(), Vec::new())]),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"foo\"\nrust-version=\"0\"".to_owned(),
false,
Path::new(""),
&[]
),
Ok(Manifest {
package: Package {
msrv: Some(Msrv {
major: 0,
minor: None,
patch: None,
}),
name: "foo".to_owned(),
},
features: Features(Vec::new()),
})
);
assert_eq!(
Manifest::from_toml(
"[\"\\u0070ackage\"]\n\"n\\u0061me\"=\"\\u0066oo\"\n\"\\u0072ust-version\"=\"0\\u002E\\u0031\"".to_owned(),
false,
Path::new(""),
&[]
),
Ok(Manifest {
package: Package {
msrv: Some(Msrv {
major: 0,
minor: Some(1),
patch: None,
}),
name: "foo".to_owned(),
},
features: Features(Vec::new()),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\nrust-version=\"0.0.0\"".to_owned(),
false,
Path::new(""),
&[]
),
Ok(Manifest {
package: Package {
msrv: Some(Msrv {
major: 0,
minor: Some(0),
patch: Some(0),
}),
name: String::new(),
},
features: Features(Vec::new()),
})
);
assert_eq!(
Manifest::from_toml("dev-dependencies=2\n[package]\nname=\"\"\n\nfoo=2\nrust-version=\"18446744073709551615.18446744073709551615.18446744073709551615\"\n[foo]\nbar=false\n[target.\"\".foo]\nbar=2\n[target.foo]\nbar=false\n[target.dependencies]\nfoo=2\n[target.build-dependencies]\nfoo=false\n[target.dev-dependencies]\nfoo=true\n".to_owned(), false, Path::new(""), &[]),
Ok(Manifest {
package: Package {
msrv: Some(Msrv {
major: u64::MAX,
minor: Some(u64::MAX),
patch: Some(u64::MAX),
}),
name: String::new(),
},
features: Features(Vec::new()),
})
);
assert_eq!(
Manifest::from_toml(
"[\"\\u0064ependencies\"]\n\"\\u0000\"=\"\\u0000\"\na={optional=true}\n[\"build-\\u0064ependencies\"]\n\"\\u0000\"={optional=true}\n[target.\"\".dependencies]\nb={optional=false,foo=2}\nfizz={optional=true,foo=3}\n[features]\ndefault=[\"bar\",\"dep:lk\",\"a/ak\",\"a/ak\"]\nbar=[\"dep\\u003Awuzz\"]\n[dev-dependencies]\nbuzz={optional=true}\n[target.a.dependencies]\nc={optional=true}\nwuzz={optional=true}\n[package]\nname=\"\"".to_owned(),
true,
Path::new(""),
&[]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![("bar".to_owned(), Vec::new()), ("default".to_owned(), vec!["bar".to_owned()]), ("a".to_owned(), Vec::new()), ("\0".to_owned(), Vec::new()), ("fizz".to_owned(), Vec::new()), ("c".to_owned(), Vec::new())]),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\n[dependencies]\nfoo={optional=true}\nfizz={optional=true}\n[features]\nfizz=[\"dep:fizz\"]\nbar=[\"dep:foo\"]".to_owned(),
false,
Path::new(""),
&[]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![
("bar".to_owned(), Vec::new()),
("fizz".to_owned(), Vec::new())
]),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\n[dependencies]\nbar={optional=true}\n[features]\nfoo=[\"bar\"]"
.to_owned(),
true,
Path::new(""),
&[]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![
("foo".to_owned(), vec!["bar".to_owned()]),
("bar".to_owned(), Vec::new()),
]),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\n[features]\na=[]\nb=[\"a\"]".to_owned(),
false,
Path::new(""),
&["a".to_owned()]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![]),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\n[features]\na=[]\nb=[\"a\"]".to_owned(),
false,
Path::new(""),
&["b".to_owned()]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![("a".to_owned(), Vec::new())]),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\n[dependencies]\nc={optional=true}\n[features]\nb=[\"c\"]"
.to_owned(),
true,
Path::new(""),
&["c".to_owned()]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![]),
})
);
assert_eq!(
Manifest::from_toml(
"[package]\nname=\"\"\n[dependencies]\nc={optional=true}\n[features]\nb=[\"c\"]"
.to_owned(),
true,
Path::new(""),
&["b".to_owned()]
),
Ok(Manifest {
package: Package {
msrv: None,
name: String::new(),
},
features: Features(vec![("c".to_owned(), Vec::new())]),
})
);
}
#[expect(clippy::unreachable, reason = "want to crash when there is a bug")]
#[expect(
clippy::cognitive_complexity,
clippy::too_many_lines,
reason = "want to test for a lot of things"
)]
#[test]
fn power_set() {
#[cfg(target_pointer_width = "16")]
let feat_len_one_too_large = 17;
#[cfg(target_pointer_width = "32")]
let feat_len_one_too_large = 33;
#[cfg(target_pointer_width = "64")]
let feat_len_one_too_large = 65;
let mut feats = Features(vec![(String::new(), Vec::new()); feat_len_one_too_large]);
assert_eq!(PowerSet::new(&feats, false), Err(TooManyFeaturesErr));
#[cfg(target_pointer_width = "16")]
let max_feat_len = 16;
#[cfg(target_pointer_width = "32")]
let max_feat_len = 32;
#[cfg(target_pointer_width = "64")]
let max_feat_len = 64;
feats.0 = vec![(String::new(), Vec::new()); max_feat_len];
#[cfg(any(
target_pointer_width = "16",
target_pointer_width = "32",
target_pointer_width = "64"
))]
assert_eq!(
PowerSet::new(&feats, false),
Ok(Some(PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: usize::MAX,
buffer: vec![""; max_feat_len],
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false,
}))
);
feats.0 = Vec::new();
assert_eq!(
PowerSet::new(&feats, false),
Ok(Some(PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false,
}))
);
assert_eq!(PowerSet::new(&feats, true), Ok(None));
let mut power_set = PowerSet::new(&feats, false)
.unwrap_or_else(|_e| {
unreachable!("not possible since we just verified PowerSet::new returned Ok")
})
.unwrap_or_else(|| {
unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
});
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
assert_eq!(power_set.next_set(), Some(""));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), None);
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), None);
power_set.reset();
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some(""));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), None);
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), None);
feats.0 = vec![
("a".to_owned(), vec!["b".to_owned()]),
("b".to_owned(), vec!["c".to_owned(), "d".to_owned()]),
("c".to_owned(), Vec::new()),
("d".to_owned(), Vec::new()),
];
assert_eq!(
PowerSet::new(&feats, false),
Ok(Some(PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: true,
idx: 15,
buffer: vec!["a", "b", "c", "d"],
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}))
);
power_set = PowerSet::new(&feats, false)
.unwrap_or_else(|_e| {
unreachable!("not possible since we just verified PowerSet::new returned Ok")
})
.unwrap_or_else(|| {
unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
});
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
assert_eq!(power_set.next_set(), Some("c,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: true,
idx: 11,
buffer: vec!["c", "d"],
set: "c,d".to_owned(),
skipped_sets_counter: 3,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: true,
idx: 7,
buffer: vec!["d"],
set: "d".to_owned(),
skipped_sets_counter: 6,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("c"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: true,
idx: 3,
buffer: vec!["c"],
set: "c".to_owned(),
skipped_sets_counter: 9,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("b"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: true,
idx: 1,
buffer: vec!["b"],
set: "b".to_owned(),
skipped_sets_counter: 10,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: true,
idx: 0,
buffer: vec!["a"],
set: "a".to_owned(),
skipped_sets_counter: 10,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some(""));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: true,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 10,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), None);
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: true,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 10,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), None);
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: true,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 10,
skip_empty_set: false
}
);
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
power_set.reset();
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: true,
idx: 15,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
feats.0 = vec![
("a".to_owned(), Vec::new()),
("b".to_owned(), Vec::new()),
("c".to_owned(), Vec::new()),
("d".to_owned(), Vec::new()),
];
assert_eq!(
PowerSet::new(&feats, false),
Ok(Some(PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 15,
buffer: vec!["a", "b", "c", "d"],
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}))
);
power_set = PowerSet::new(&feats, false)
.unwrap_or_else(|_e| {
unreachable!("not possible since we just verified PowerSet::new returned Ok")
})
.unwrap_or_else(|| {
unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
});
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
assert_eq!(power_set.next_set(), Some("a,b,c,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 14,
buffer: vec!["a", "b", "c", "d"],
set: "a,b,c,d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("b,c,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 13,
buffer: vec!["b", "c", "d"],
set: "b,c,d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a,c,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 12,
buffer: vec!["a", "c", "d"],
set: "a,c,d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("c,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 11,
buffer: vec!["c", "d"],
set: "c,d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a,b,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 10,
buffer: vec!["a", "b", "d"],
set: "a,b,d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("b,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 9,
buffer: vec!["b", "d"],
set: "b,d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a,d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 8,
buffer: vec!["a", "d"],
set: "a,d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("d"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 7,
buffer: vec!["d"],
set: "d".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a,b,c"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 6,
buffer: vec!["a", "b", "c"],
set: "a,b,c".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("b,c"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 5,
buffer: vec!["b", "c"],
set: "b,c".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a,c"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 4,
buffer: vec!["a", "c"],
set: "a,c".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("c"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 3,
buffer: vec!["c"],
set: "c".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a,b"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 2,
buffer: vec!["a", "b"],
set: "a,b".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("b"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 1,
buffer: vec!["b"],
set: "b".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some("a"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 0,
buffer: vec!["a"],
set: "a".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), Some(""));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.next_set(), None);
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: Vec::new(),
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: false
}
);
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
feats.0 = vec![("a".to_owned(), Vec::new())];
assert_eq!(
PowerSet::new(&feats, true),
Ok(Some(PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 1,
buffer: vec!["a"],
set: String::new(),
skipped_sets_counter: 0,
skip_empty_set: true
}))
);
power_set = PowerSet::new(&feats, true)
.unwrap_or_else(|_e| {
unreachable!("not possible since we just verified PowerSet::new returned Ok")
})
.unwrap_or_else(|| {
unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
});
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
assert_eq!(power_set.next_set(), Some("a"));
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: vec!["a"],
set: "a".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: true,
}
);
assert_eq!(power_set.next_set(), None);
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: vec!["a"],
set: "a".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: true,
}
);
assert_eq!(power_set.next_set(), None);
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: vec!["a"],
set: "a".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: true,
}
);
power_set.reset();
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: true,
check_overlap: false,
idx: 1,
buffer: vec!["a"],
set: "a".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: true,
}
);
assert_eq!(power_set.next_set(), Some("a"));
assert_eq!(power_set.next_set(), None);
assert_eq!(
power_set,
PowerSet {
feats: feats.0.as_slice(),
has_remaining: false,
check_overlap: false,
idx: 0,
buffer: vec!["a"],
set: "a".to_owned(),
skipped_sets_counter: 0,
skip_empty_set: true,
}
);
assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
}