508 

   509 #[cfg(test)]

   510 mod tests {

   511     use super::*;

   512     use crate::index::{IndexEntryBuilder, INDEX_ENTRY_SIZE};

   513     use itertools::Itertools;

   514 

   515     #[test]

   516     fn test_empty() {

   517         let temp = tempfile::tempdir().unwrap();

   518         let vfs = Vfs { base: temp.path() };

   519         std::fs::write(temp.path().join("foo.i"), b"").unwrap();

   520         let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();

   521         assert!(revlog.is_empty());

   522         assert_eq!(revlog.len(), 0);

   523         assert!(revlog.get_entry(0).is_err());

   524         assert!(!revlog.has_rev(0));

   525     }

   526 

   527     #[test]

   528     fn test_inline() {

   529         let temp = tempfile::tempdir().unwrap();

   530         let vfs = Vfs { base: temp.path() };

   531         let node0 = Node::from_hex("2ed2a3912a0b24502043eae84ee4b279c18b90dd")

   532             .unwrap();

   533         let node1 = Node::from_hex("b004912a8510032a0350a74daa2803dadfb00e12")

   534             .unwrap();

   535         let node2 = Node::from_hex("dd6ad206e907be60927b5a3117b97dffb2590582")

   536             .unwrap();

   537         let entry0_bytes = IndexEntryBuilder::new()

   538             .is_first(true)

   539             .with_version(1)

   540             .with_inline(true)

   541             .with_offset(INDEX_ENTRY_SIZE)

   542             .with_node(node0)

   543             .build();

   544         let entry1_bytes = IndexEntryBuilder::new()

   545             .with_offset(INDEX_ENTRY_SIZE)

   546             .with_node(node1)

   547             .build();

   548         let entry2_bytes = IndexEntryBuilder::new()

   549             .with_offset(INDEX_ENTRY_SIZE)

   550             .with_p1(0)

   551             .with_p2(1)

   552             .with_node(node2)

   553             .build();

   554         let contents = vec![entry0_bytes, entry1_bytes, entry2_bytes]

   555             .into_iter()

   556             .flatten()

   557             .collect_vec();

   558         std::fs::write(temp.path().join("foo.i"), contents).unwrap();

   559         let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();

   560 

   561         let entry0 = revlog.get_entry(0).ok().unwrap();

   562         assert_eq!(entry0.revision(), 0);

   563         assert_eq!(*entry0.node(), node0);

   564         assert!(!entry0.has_p1());

   565         assert_eq!(entry0.p1(), None);

   566         assert_eq!(entry0.p2(), None);

   567         let p1_entry = entry0.p1_entry().unwrap();

   568         assert!(p1_entry.is_none());

   569         let p2_entry = entry0.p2_entry().unwrap();

   570         assert!(p2_entry.is_none());

   571 

   572         let entry1 = revlog.get_entry(1).ok().unwrap();

   573         assert_eq!(entry1.revision(), 1);

   574         assert_eq!(*entry1.node(), node1);

   575         assert!(!entry1.has_p1());

   576         assert_eq!(entry1.p1(), None);

   577         assert_eq!(entry1.p2(), None);

   578         let p1_entry = entry1.p1_entry().unwrap();

   579         assert!(p1_entry.is_none());

   580         let p2_entry = entry1.p2_entry().unwrap();

   581         assert!(p2_entry.is_none());

   582 

   583         let entry2 = revlog.get_entry(2).ok().unwrap();

   584         assert_eq!(entry2.revision(), 2);

   585         assert_eq!(*entry2.node(), node2);

   586         assert!(entry2.has_p1());

   587         assert_eq!(entry2.p1(), Some(0));

   588         assert_eq!(entry2.p2(), Some(1));

   589         let p1_entry = entry2.p1_entry().unwrap();

   590         assert!(p1_entry.is_some());

   591         assert_eq!(p1_entry.unwrap().revision(), 0);

   592         let p2_entry = entry2.p2_entry().unwrap();

   593         assert!(p2_entry.is_some());

   594         assert_eq!(p2_entry.unwrap().revision(), 1);

   595     }

   596 }