}
quickcheck! {
  fn printable_dep_roundtrip(d1: PrintableDep) -> () {
      let mut w = Vec::new();
      writeln!(&mut w, "{}", &d1).unwrap();
      let utf = std::str::from_utf8(&w).unwrap();
      let (_, d2) = parse_dependency(utf).unwrap();
      assert_eq!(d1, d2);
  }

}
impl fmt::Display for PrintableDep {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}{}", self.type_, self.hash)
    }

}
impl fmt::Display for DepType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Self::Numbered(n, p) = self {
            write!(f, "[{n}]{}", if *p { '+' } else { ' ' })
        } else {
            write!(
                f,
                "[{}] ",
                if matches!(self, Self::ExtraKnown) {
                    '*'
                } else {
                    ' '
                }
            )
        }
    }

#[cfg(test)]
impl Arbitrary for PrintableDep {
    fn arbitrary(g: &mut Gen) -> Self {
        let hash = Hash::Blake3(std::array::from_fn(|_| Arbitrary::arbitrary(g))).to_base32();
        Self {
            type_: Arbitrary::arbitrary(g),
            hash,
        }
    }
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        Box::new(
            (self.type_.clone(), self.hash.clone())
                .shrink()
                .map(|(type_, hash)| Self { type_, hash }),
        )
    }
}
#[cfg(test)]
impl Arbitrary for DepType {
    fn arbitrary(g: &mut Gen) -> Self {
        let options = [
            Self::ExtraKnown,
            Self::ExtraUnknown,
            Self::Numbered(Arbitrary::arbitrary(g), Arbitrary::arbitrary(g)),
        ];
        g.choose(&options).unwrap().clone()
    }
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        match self {
            DepType::ExtraKnown | DepType::ExtraUnknown => Box::new(std::iter::empty()),
            DepType::Numbered(n, p) => {
                Box::new((*n, *p).shrink().map(|(n, p)| Self::Numbered(n, p)))
            }
        }
    }
}