fn test_insert_leading()

in focus/internals/src/lib/model/outlining.rs [415:529]
113 lines of code
1 McCabe index (conditional complexity)

    fn test_insert_leading() {
        let mut pattern_set = PatternSet::new();
        let mut recursive_paths = HashSet::<PathBuf>::new();
        recursive_paths.insert(PathBuf::from("1/2/3"));
        let nested_pattern = Pattern::Directory {
            precedence: 0,
            path: PathBuf::from("a/b/c/d/e"),
            recursive: true,
        };
        let nested_pattern_with_ceiling = Pattern::Directory {
            precedence: 1,
            path: PathBuf::from("1/2/3"),
            recursive: true,
        };
        let nested_pattern_exceeding_ceiling = Pattern::Directory {
            precedence: 2,
            path: PathBuf::from("1/2/3/4/5/6"),
            recursive: true,
        };
        pattern_set.insert_leading(nested_pattern, &recursive_paths);
        pattern_set.insert_leading(nested_pattern_with_ceiling, &recursive_paths);
        pattern_set.insert_leading(nested_pattern_exceeding_ceiling, &recursive_paths);
        let mut iter = pattern_set.iter();
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 0,
                path: PathBuf::from("a"),
                recursive: true,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 0,
                path: PathBuf::from("a/b"),
                recursive: true,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 0,
                path: PathBuf::from("a/b/c"),
                recursive: true,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 0,
                path: PathBuf::from("a/b/c/d"),
                recursive: true,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 0,
                path: PathBuf::from("a/b/c/d/e"),
                recursive: true,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 1,
                path: PathBuf::from("1"),
                recursive: false,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 1,
                path: PathBuf::from("1/2"),
                recursive: false,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 1,
                path: PathBuf::from("1/2/3"),
                recursive: true,
            }
        );
        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 2,
                path: PathBuf::from("1/2/3/4"),
                recursive: false,
            }
        );

        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 2,
                path: PathBuf::from("1/2/3/4/5"),
                recursive: false,
            }
        );

        assert_eq!(
            iter.next().unwrap(),
            &Pattern::Directory {
                precedence: 2,
                path: PathBuf::from("1/2/3/4/5/6"),
                recursive: false,
            }
        );
        assert!(iter.next().is_none());
    }