// Automatically generated on: 2023-02-01 08:22:07.769288 .

mod graph_attributes {

    use causal_hub::io::dot::attributes::GraphAttributes;

    #[test]
    fn background() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_background());
        assert!(attributes.set_background("TEST"));
        assert!(attributes.unset_background());
    }

    #[test]
    fn bb() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_bb());
        assert!(attributes.set_bb("TEST"));
        assert!(attributes.unset_bb());
    }

    #[test]
    fn beautify() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_beautify());
        assert!(attributes.set_beautify("TEST"));
        assert!(attributes.unset_beautify());
    }

    #[test]
    fn bgcolor() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_bgcolor());
        assert!(attributes.set_bgcolor("TEST"));
        assert!(attributes.unset_bgcolor());
    }

    #[test]
    fn center() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_center());
        assert!(attributes.set_center("TEST"));
        assert!(attributes.unset_center());
    }

    #[test]
    fn charset() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_charset());
        assert!(attributes.set_charset("TEST"));
        assert!(attributes.unset_charset());
    }

    #[test]
    fn class() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_class());
        assert!(attributes.set_class("TEST"));
        assert!(attributes.unset_class());
    }

    #[test]
    fn clusterrank() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_clusterrank());
        assert!(attributes.set_clusterrank("TEST"));
        assert!(attributes.unset_clusterrank());
    }

    #[test]
    fn colorscheme() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_colorscheme());
        assert!(attributes.set_colorscheme("TEST"));
        assert!(attributes.unset_colorscheme());
    }

    #[test]
    fn comment() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_comment());
        assert!(attributes.set_comment("TEST"));
        assert!(attributes.unset_comment());
    }

    #[test]
    fn compound() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_compound());
        assert!(attributes.set_compound("TEST"));
        assert!(attributes.unset_compound());
    }

    #[test]
    fn concentrate() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_concentrate());
        assert!(attributes.set_concentrate("TEST"));
        assert!(attributes.unset_concentrate());
    }

    #[test]
    fn damping() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_damping());
        assert!(attributes.set_damping("TEST"));
        assert!(attributes.unset_damping());
    }

    #[test]
    fn defaultdist() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_defaultdist());
        assert!(attributes.set_defaultdist("TEST"));
        assert!(attributes.unset_defaultdist());
    }

    #[test]
    fn dim() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_dim());
        assert!(attributes.set_dim("TEST"));
        assert!(attributes.unset_dim());
    }

    #[test]
    fn dimen() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_dimen());
        assert!(attributes.set_dimen("TEST"));
        assert!(attributes.unset_dimen());
    }

    #[test]
    fn diredgeconstraints() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_diredgeconstraints());
        assert!(attributes.set_diredgeconstraints("TEST"));
        assert!(attributes.unset_diredgeconstraints());
    }

    #[test]
    fn dpi() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_dpi());
        assert!(attributes.set_dpi("TEST"));
        assert!(attributes.unset_dpi());
    }

    #[test]
    fn epsilon() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_epsilon());
        assert!(attributes.set_epsilon("TEST"));
        assert!(attributes.unset_epsilon());
    }

    #[test]
    fn esep() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_esep());
        assert!(attributes.set_esep("TEST"));
        assert!(attributes.unset_esep());
    }

    #[test]
    fn fontcolor() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_fontcolor());
        assert!(attributes.set_fontcolor("TEST"));
        assert!(attributes.unset_fontcolor());
    }

    #[test]
    fn fontname() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_fontname());
        assert!(attributes.set_fontname("TEST"));
        assert!(attributes.unset_fontname());
    }

    #[test]
    fn fontnames() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_fontnames());
        assert!(attributes.set_fontnames("TEST"));
        assert!(attributes.unset_fontnames());
    }

    #[test]
    fn fontpath() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_fontpath());
        assert!(attributes.set_fontpath("TEST"));
        assert!(attributes.unset_fontpath());
    }

    #[test]
    fn fontsize() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_fontsize());
        assert!(attributes.set_fontsize("TEST"));
        assert!(attributes.unset_fontsize());
    }

    #[test]
    fn forcelabels() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_forcelabels());
        assert!(attributes.set_forcelabels("TEST"));
        assert!(attributes.unset_forcelabels());
    }

    #[test]
    fn gradientangle() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_gradientangle());
        assert!(attributes.set_gradientangle("TEST"));
        assert!(attributes.unset_gradientangle());
    }

    #[test]
    fn href() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_href());
        assert!(attributes.set_href("TEST"));
        assert!(attributes.unset_href());
    }

    #[test]
    fn id() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_id());
        assert!(attributes.set_id("TEST"));
        assert!(attributes.unset_id());
    }

    #[test]
    fn imagepath() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_imagepath());
        assert!(attributes.set_imagepath("TEST"));
        assert!(attributes.unset_imagepath());
    }

    #[test]
    fn inputscale() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_inputscale());
        assert!(attributes.set_inputscale("TEST"));
        assert!(attributes.unset_inputscale());
    }

    #[test]
    fn k() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_k());
        assert!(attributes.set_k("TEST"));
        assert!(attributes.unset_k());
    }

    #[test]
    fn label() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_label());
        assert!(attributes.set_label("TEST"));
        assert!(attributes.unset_label());
    }

    #[test]
    fn label_scheme() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_label_scheme());
        assert!(attributes.set_label_scheme("TEST"));
        assert!(attributes.unset_label_scheme());
    }

    #[test]
    fn labeljust() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_labeljust());
        assert!(attributes.set_labeljust("TEST"));
        assert!(attributes.unset_labeljust());
    }

    #[test]
    fn labelloc() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_labelloc());
        assert!(attributes.set_labelloc("TEST"));
        assert!(attributes.unset_labelloc());
    }

    #[test]
    fn landscape() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_landscape());
        assert!(attributes.set_landscape("TEST"));
        assert!(attributes.unset_landscape());
    }

    #[test]
    fn layerlistsep() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_layerlistsep());
        assert!(attributes.set_layerlistsep("TEST"));
        assert!(attributes.unset_layerlistsep());
    }

    #[test]
    fn layers() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_layers());
        assert!(attributes.set_layers("TEST"));
        assert!(attributes.unset_layers());
    }

    #[test]
    fn layerselect() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_layerselect());
        assert!(attributes.set_layerselect("TEST"));
        assert!(attributes.unset_layerselect());
    }

    #[test]
    fn layersep() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_layersep());
        assert!(attributes.set_layersep("TEST"));
        assert!(attributes.unset_layersep());
    }

    #[test]
    fn layout() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_layout());
        assert!(attributes.set_layout("TEST"));
        assert!(attributes.unset_layout());
    }

    #[test]
    fn levels() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_levels());
        assert!(attributes.set_levels("TEST"));
        assert!(attributes.unset_levels());
    }

    #[test]
    fn levelsgap() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_levelsgap());
        assert!(attributes.set_levelsgap("TEST"));
        assert!(attributes.unset_levelsgap());
    }

    #[test]
    fn lheight() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_lheight());
        assert!(attributes.set_lheight("TEST"));
        assert!(attributes.unset_lheight());
    }

    #[test]
    fn linelength() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_linelength());
        assert!(attributes.set_linelength("TEST"));
        assert!(attributes.unset_linelength());
    }

    #[test]
    fn lp() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_lp());
        assert!(attributes.set_lp("TEST"));
        assert!(attributes.unset_lp());
    }

    #[test]
    fn lwidth() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_lwidth());
        assert!(attributes.set_lwidth("TEST"));
        assert!(attributes.unset_lwidth());
    }

    #[test]
    fn margin() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_margin());
        assert!(attributes.set_margin("TEST"));
        assert!(attributes.unset_margin());
    }

    #[test]
    fn maxiter() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_maxiter());
        assert!(attributes.set_maxiter("TEST"));
        assert!(attributes.unset_maxiter());
    }

    #[test]
    fn mclimit() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_mclimit());
        assert!(attributes.set_mclimit("TEST"));
        assert!(attributes.unset_mclimit());
    }

    #[test]
    fn mindist() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_mindist());
        assert!(attributes.set_mindist("TEST"));
        assert!(attributes.unset_mindist());
    }

    #[test]
    fn mode() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_mode());
        assert!(attributes.set_mode("TEST"));
        assert!(attributes.unset_mode());
    }

    #[test]
    fn model() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_model());
        assert!(attributes.set_model("TEST"));
        assert!(attributes.unset_model());
    }

    #[test]
    fn newrank() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_newrank());
        assert!(attributes.set_newrank("TEST"));
        assert!(attributes.unset_newrank());
    }

    #[test]
    fn nodesep() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_nodesep());
        assert!(attributes.set_nodesep("TEST"));
        assert!(attributes.unset_nodesep());
    }

    #[test]
    fn nojustify() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_nojustify());
        assert!(attributes.set_nojustify("TEST"));
        assert!(attributes.unset_nojustify());
    }

    #[test]
    fn normalize() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_normalize());
        assert!(attributes.set_normalize("TEST"));
        assert!(attributes.unset_normalize());
    }

    #[test]
    fn notranslate() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_notranslate());
        assert!(attributes.set_notranslate("TEST"));
        assert!(attributes.unset_notranslate());
    }

    #[test]
    fn nslimit() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_nslimit());
        assert!(attributes.set_nslimit("TEST"));
        assert!(attributes.unset_nslimit());
    }

    #[test]
    fn nslimit1() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_nslimit1());
        assert!(attributes.set_nslimit1("TEST"));
        assert!(attributes.unset_nslimit1());
    }

    #[test]
    fn oneblock() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_oneblock());
        assert!(attributes.set_oneblock("TEST"));
        assert!(attributes.unset_oneblock());
    }

    #[test]
    fn ordering() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_ordering());
        assert!(attributes.set_ordering("TEST"));
        assert!(attributes.unset_ordering());
    }

    #[test]
    fn orientation() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_orientation());
        assert!(attributes.set_orientation("TEST"));
        assert!(attributes.unset_orientation());
    }

    #[test]
    fn outputorder() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_outputorder());
        assert!(attributes.set_outputorder("TEST"));
        assert!(attributes.unset_outputorder());
    }

    #[test]
    fn overlap() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_overlap());
        assert!(attributes.set_overlap("TEST"));
        assert!(attributes.unset_overlap());
    }

    #[test]
    fn overlap_scaling() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_overlap_scaling());
        assert!(attributes.set_overlap_scaling("TEST"));
        assert!(attributes.unset_overlap_scaling());
    }

    #[test]
    fn overlap_shrink() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_overlap_shrink());
        assert!(attributes.set_overlap_shrink("TEST"));
        assert!(attributes.unset_overlap_shrink());
    }

    #[test]
    fn pack() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_pack());
        assert!(attributes.set_pack("TEST"));
        assert!(attributes.unset_pack());
    }

    #[test]
    fn packmode() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_packmode());
        assert!(attributes.set_packmode("TEST"));
        assert!(attributes.unset_packmode());
    }

    #[test]
    fn pad() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_pad());
        assert!(attributes.set_pad("TEST"));
        assert!(attributes.unset_pad());
    }

    #[test]
    fn page() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_page());
        assert!(attributes.set_page("TEST"));
        assert!(attributes.unset_page());
    }

    #[test]
    fn pagedir() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_pagedir());
        assert!(attributes.set_pagedir("TEST"));
        assert!(attributes.unset_pagedir());
    }

    #[test]
    fn quadtree() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_quadtree());
        assert!(attributes.set_quadtree("TEST"));
        assert!(attributes.unset_quadtree());
    }

    #[test]
    fn quantum() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_quantum());
        assert!(attributes.set_quantum("TEST"));
        assert!(attributes.unset_quantum());
    }

    #[test]
    fn rankdir() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_rankdir());
        assert!(attributes.set_rankdir("TEST"));
        assert!(attributes.unset_rankdir());
    }

    #[test]
    fn ranksep() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_ranksep());
        assert!(attributes.set_ranksep("TEST"));
        assert!(attributes.unset_ranksep());
    }

    #[test]
    fn ratio() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_ratio());
        assert!(attributes.set_ratio("TEST"));
        assert!(attributes.unset_ratio());
    }

    #[test]
    fn remincross() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_remincross());
        assert!(attributes.set_remincross("TEST"));
        assert!(attributes.unset_remincross());
    }

    #[test]
    fn repulsiveforce() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_repulsiveforce());
        assert!(attributes.set_repulsiveforce("TEST"));
        assert!(attributes.unset_repulsiveforce());
    }

    #[test]
    fn resolution() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_resolution());
        assert!(attributes.set_resolution("TEST"));
        assert!(attributes.unset_resolution());
    }

    #[test]
    fn root() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_root());
        assert!(attributes.set_root("TEST"));
        assert!(attributes.unset_root());
    }

    #[test]
    fn rotate() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_rotate());
        assert!(attributes.set_rotate("TEST"));
        assert!(attributes.unset_rotate());
    }

    #[test]
    fn rotation() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_rotation());
        assert!(attributes.set_rotation("TEST"));
        assert!(attributes.unset_rotation());
    }

    #[test]
    fn scale() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_scale());
        assert!(attributes.set_scale("TEST"));
        assert!(attributes.unset_scale());
    }

    #[test]
    fn searchsize() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_searchsize());
        assert!(attributes.set_searchsize("TEST"));
        assert!(attributes.unset_searchsize());
    }

    #[test]
    fn sep() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_sep());
        assert!(attributes.set_sep("TEST"));
        assert!(attributes.unset_sep());
    }

    #[test]
    fn showboxes() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_showboxes());
        assert!(attributes.set_showboxes("TEST"));
        assert!(attributes.unset_showboxes());
    }

    #[test]
    fn size() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_size());
        assert!(attributes.set_size("TEST"));
        assert!(attributes.unset_size());
    }

    #[test]
    fn smoothing() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_smoothing());
        assert!(attributes.set_smoothing("TEST"));
        assert!(attributes.unset_smoothing());
    }

    #[test]
    fn sortv() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_sortv());
        assert!(attributes.set_sortv("TEST"));
        assert!(attributes.unset_sortv());
    }

    #[test]
    fn splines() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_splines());
        assert!(attributes.set_splines("TEST"));
        assert!(attributes.unset_splines());
    }

    #[test]
    fn start() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_start());
        assert!(attributes.set_start("TEST"));
        assert!(attributes.unset_start());
    }

    #[test]
    fn style() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_style());
        assert!(attributes.set_style("TEST"));
        assert!(attributes.unset_style());
    }

    #[test]
    fn stylesheet() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_stylesheet());
        assert!(attributes.set_stylesheet("TEST"));
        assert!(attributes.unset_stylesheet());
    }

    #[test]
    fn target() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_target());
        assert!(attributes.set_target("TEST"));
        assert!(attributes.unset_target());
    }

    #[test]
    fn tbbalance() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_tbbalance());
        assert!(attributes.set_tbbalance("TEST"));
        assert!(attributes.unset_tbbalance());
    }

    #[test]
    fn tooltip() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_tooltip());
        assert!(attributes.set_tooltip("TEST"));
        assert!(attributes.unset_tooltip());
    }

    #[test]
    fn truecolor() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_truecolor());
        assert!(attributes.set_truecolor("TEST"));
        assert!(attributes.unset_truecolor());
    }

    #[test]
    fn url() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_url());
        assert!(attributes.set_url("TEST"));
        assert!(attributes.unset_url());
    }

    #[test]
    fn viewport() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_viewport());
        assert!(attributes.set_viewport("TEST"));
        assert!(attributes.unset_viewport());
    }

    #[test]
    fn voro_margin() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_voro_margin());
        assert!(attributes.set_voro_margin("TEST"));
        assert!(attributes.unset_voro_margin());
    }

    #[test]
    fn xdotversion() {
        let mut attributes: GraphAttributes = Default::default();
        assert!(!attributes.unset_xdotversion());
        assert!(attributes.set_xdotversion("TEST"));
        assert!(attributes.unset_xdotversion());
    }
}

mod vertex_attributes {

    use causal_hub::io::dot::attributes::VertexAttributes;

    #[test]
    fn area() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_area());
        assert!(attributes.set_area("TEST"));
        assert!(attributes.unset_area());
    }

    #[test]
    fn class() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_class());
        assert!(attributes.set_class("TEST"));
        assert!(attributes.unset_class());
    }

    #[test]
    fn color() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_color());
        assert!(attributes.set_color("TEST"));
        assert!(attributes.unset_color());
    }

    #[test]
    fn colorscheme() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_colorscheme());
        assert!(attributes.set_colorscheme("TEST"));
        assert!(attributes.unset_colorscheme());
    }

    #[test]
    fn comment() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_comment());
        assert!(attributes.set_comment("TEST"));
        assert!(attributes.unset_comment());
    }

    #[test]
    fn distortion() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_distortion());
        assert!(attributes.set_distortion("TEST"));
        assert!(attributes.unset_distortion());
    }

    #[test]
    fn fillcolor() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_fillcolor());
        assert!(attributes.set_fillcolor("TEST"));
        assert!(attributes.unset_fillcolor());
    }

    #[test]
    fn fixedsize() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_fixedsize());
        assert!(attributes.set_fixedsize("TEST"));
        assert!(attributes.unset_fixedsize());
    }

    #[test]
    fn fontcolor() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_fontcolor());
        assert!(attributes.set_fontcolor("TEST"));
        assert!(attributes.unset_fontcolor());
    }

    #[test]
    fn fontname() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_fontname());
        assert!(attributes.set_fontname("TEST"));
        assert!(attributes.unset_fontname());
    }

    #[test]
    fn fontsize() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_fontsize());
        assert!(attributes.set_fontsize("TEST"));
        assert!(attributes.unset_fontsize());
    }

    #[test]
    fn gradientangle() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_gradientangle());
        assert!(attributes.set_gradientangle("TEST"));
        assert!(attributes.unset_gradientangle());
    }

    #[test]
    fn group() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_group());
        assert!(attributes.set_group("TEST"));
        assert!(attributes.unset_group());
    }

    #[test]
    fn height() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_height());
        assert!(attributes.set_height("TEST"));
        assert!(attributes.unset_height());
    }

    #[test]
    fn href() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_href());
        assert!(attributes.set_href("TEST"));
        assert!(attributes.unset_href());
    }

    #[test]
    fn id() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_id());
        assert!(attributes.set_id("TEST"));
        assert!(attributes.unset_id());
    }

    #[test]
    fn image() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_image());
        assert!(attributes.set_image("TEST"));
        assert!(attributes.unset_image());
    }

    #[test]
    fn imagepos() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_imagepos());
        assert!(attributes.set_imagepos("TEST"));
        assert!(attributes.unset_imagepos());
    }

    #[test]
    fn imagescale() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_imagescale());
        assert!(attributes.set_imagescale("TEST"));
        assert!(attributes.unset_imagescale());
    }

    #[test]
    fn label() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_label());
        assert!(attributes.set_label("TEST"));
        assert!(attributes.unset_label());
    }

    #[test]
    fn labelloc() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_labelloc());
        assert!(attributes.set_labelloc("TEST"));
        assert!(attributes.unset_labelloc());
    }

    #[test]
    fn layer() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_layer());
        assert!(attributes.set_layer("TEST"));
        assert!(attributes.unset_layer());
    }

    #[test]
    fn margin() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_margin());
        assert!(attributes.set_margin("TEST"));
        assert!(attributes.unset_margin());
    }

    #[test]
    fn nojustify() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_nojustify());
        assert!(attributes.set_nojustify("TEST"));
        assert!(attributes.unset_nojustify());
    }

    #[test]
    fn ordering() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_ordering());
        assert!(attributes.set_ordering("TEST"));
        assert!(attributes.unset_ordering());
    }

    #[test]
    fn orientation() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_orientation());
        assert!(attributes.set_orientation("TEST"));
        assert!(attributes.unset_orientation());
    }

    #[test]
    fn penwidth() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_penwidth());
        assert!(attributes.set_penwidth("TEST"));
        assert!(attributes.unset_penwidth());
    }

    #[test]
    fn peripheries() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_peripheries());
        assert!(attributes.set_peripheries("TEST"));
        assert!(attributes.unset_peripheries());
    }

    #[test]
    fn pin() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_pin());
        assert!(attributes.set_pin("TEST"));
        assert!(attributes.unset_pin());
    }

    #[test]
    fn pos() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_pos());
        assert!(attributes.set_pos("TEST"));
        assert!(attributes.unset_pos());
    }

    #[test]
    fn rects() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_rects());
        assert!(attributes.set_rects("TEST"));
        assert!(attributes.unset_rects());
    }

    #[test]
    fn regular() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_regular());
        assert!(attributes.set_regular("TEST"));
        assert!(attributes.unset_regular());
    }

    #[test]
    fn root() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_root());
        assert!(attributes.set_root("TEST"));
        assert!(attributes.unset_root());
    }

    #[test]
    fn samplepoints() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_samplepoints());
        assert!(attributes.set_samplepoints("TEST"));
        assert!(attributes.unset_samplepoints());
    }

    #[test]
    fn shape() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_shape());
        assert!(attributes.set_shape("TEST"));
        assert!(attributes.unset_shape());
    }

    #[test]
    fn shapefile() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_shapefile());
        assert!(attributes.set_shapefile("TEST"));
        assert!(attributes.unset_shapefile());
    }

    #[test]
    fn showboxes() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_showboxes());
        assert!(attributes.set_showboxes("TEST"));
        assert!(attributes.unset_showboxes());
    }

    #[test]
    fn sides() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_sides());
        assert!(attributes.set_sides("TEST"));
        assert!(attributes.unset_sides());
    }

    #[test]
    fn skew() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_skew());
        assert!(attributes.set_skew("TEST"));
        assert!(attributes.unset_skew());
    }

    #[test]
    fn sortv() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_sortv());
        assert!(attributes.set_sortv("TEST"));
        assert!(attributes.unset_sortv());
    }

    #[test]
    fn style() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_style());
        assert!(attributes.set_style("TEST"));
        assert!(attributes.unset_style());
    }

    #[test]
    fn target() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_target());
        assert!(attributes.set_target("TEST"));
        assert!(attributes.unset_target());
    }

    #[test]
    fn tooltip() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_tooltip());
        assert!(attributes.set_tooltip("TEST"));
        assert!(attributes.unset_tooltip());
    }

    #[test]
    fn url() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_url());
        assert!(attributes.set_url("TEST"));
        assert!(attributes.unset_url());
    }

    #[test]
    fn vertices() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_vertices());
        assert!(attributes.set_vertices("TEST"));
        assert!(attributes.unset_vertices());
    }

    #[test]
    fn width() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_width());
        assert!(attributes.set_width("TEST"));
        assert!(attributes.unset_width());
    }

    #[test]
    fn xlabel() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_xlabel());
        assert!(attributes.set_xlabel("TEST"));
        assert!(attributes.unset_xlabel());
    }

    #[test]
    fn xlp() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_xlp());
        assert!(attributes.set_xlp("TEST"));
        assert!(attributes.unset_xlp());
    }

    #[test]
    fn z() {
        let mut attributes: VertexAttributes = Default::default();
        assert!(!attributes.unset_z());
        assert!(attributes.set_z("TEST"));
        assert!(attributes.unset_z());
    }
}

mod cluster_attributes {

    use causal_hub::io::dot::attributes::ClusterAttributes;

    #[test]
    fn area() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_area());
        assert!(attributes.set_area("TEST"));
        assert!(attributes.unset_area());
    }

    #[test]
    fn bgcolor() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_bgcolor());
        assert!(attributes.set_bgcolor("TEST"));
        assert!(attributes.unset_bgcolor());
    }

    #[test]
    fn class() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_class());
        assert!(attributes.set_class("TEST"));
        assert!(attributes.unset_class());
    }

    #[test]
    fn cluster() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_cluster());
        assert!(attributes.set_cluster("TEST"));
        assert!(attributes.unset_cluster());
    }

    #[test]
    fn color() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_color());
        assert!(attributes.set_color("TEST"));
        assert!(attributes.unset_color());
    }

    #[test]
    fn colorscheme() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_colorscheme());
        assert!(attributes.set_colorscheme("TEST"));
        assert!(attributes.unset_colorscheme());
    }

    #[test]
    fn fillcolor() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_fillcolor());
        assert!(attributes.set_fillcolor("TEST"));
        assert!(attributes.unset_fillcolor());
    }

    #[test]
    fn fontcolor() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_fontcolor());
        assert!(attributes.set_fontcolor("TEST"));
        assert!(attributes.unset_fontcolor());
    }

    #[test]
    fn fontname() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_fontname());
        assert!(attributes.set_fontname("TEST"));
        assert!(attributes.unset_fontname());
    }

    #[test]
    fn fontsize() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_fontsize());
        assert!(attributes.set_fontsize("TEST"));
        assert!(attributes.unset_fontsize());
    }

    #[test]
    fn gradientangle() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_gradientangle());
        assert!(attributes.set_gradientangle("TEST"));
        assert!(attributes.unset_gradientangle());
    }

    #[test]
    fn href() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_href());
        assert!(attributes.set_href("TEST"));
        assert!(attributes.unset_href());
    }

    #[test]
    fn id() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_id());
        assert!(attributes.set_id("TEST"));
        assert!(attributes.unset_id());
    }

    #[test]
    fn k() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_k());
        assert!(attributes.set_k("TEST"));
        assert!(attributes.unset_k());
    }

    #[test]
    fn label() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_label());
        assert!(attributes.set_label("TEST"));
        assert!(attributes.unset_label());
    }

    #[test]
    fn labeljust() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_labeljust());
        assert!(attributes.set_labeljust("TEST"));
        assert!(attributes.unset_labeljust());
    }

    #[test]
    fn labelloc() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_labelloc());
        assert!(attributes.set_labelloc("TEST"));
        assert!(attributes.unset_labelloc());
    }

    #[test]
    fn layer() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_layer());
        assert!(attributes.set_layer("TEST"));
        assert!(attributes.unset_layer());
    }

    #[test]
    fn lheight() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_lheight());
        assert!(attributes.set_lheight("TEST"));
        assert!(attributes.unset_lheight());
    }

    #[test]
    fn lp() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_lp());
        assert!(attributes.set_lp("TEST"));
        assert!(attributes.unset_lp());
    }

    #[test]
    fn lwidth() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_lwidth());
        assert!(attributes.set_lwidth("TEST"));
        assert!(attributes.unset_lwidth());
    }

    #[test]
    fn margin() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_margin());
        assert!(attributes.set_margin("TEST"));
        assert!(attributes.unset_margin());
    }

    #[test]
    fn nojustify() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_nojustify());
        assert!(attributes.set_nojustify("TEST"));
        assert!(attributes.unset_nojustify());
    }

    #[test]
    fn pencolor() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_pencolor());
        assert!(attributes.set_pencolor("TEST"));
        assert!(attributes.unset_pencolor());
    }

    #[test]
    fn penwidth() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_penwidth());
        assert!(attributes.set_penwidth("TEST"));
        assert!(attributes.unset_penwidth());
    }

    #[test]
    fn peripheries() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_peripheries());
        assert!(attributes.set_peripheries("TEST"));
        assert!(attributes.unset_peripheries());
    }

    #[test]
    fn sortv() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_sortv());
        assert!(attributes.set_sortv("TEST"));
        assert!(attributes.unset_sortv());
    }

    #[test]
    fn style() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_style());
        assert!(attributes.set_style("TEST"));
        assert!(attributes.unset_style());
    }

    #[test]
    fn target() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_target());
        assert!(attributes.set_target("TEST"));
        assert!(attributes.unset_target());
    }

    #[test]
    fn tooltip() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_tooltip());
        assert!(attributes.set_tooltip("TEST"));
        assert!(attributes.unset_tooltip());
    }

    #[test]
    fn url() {
        let mut attributes: ClusterAttributes = Default::default();
        assert!(!attributes.unset_url());
        assert!(attributes.set_url("TEST"));
        assert!(attributes.unset_url());
    }
}

mod edge_attributes {

    use causal_hub::io::dot::attributes::EdgeAttributes;

    #[test]
    fn arrowhead() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_arrowhead());
        assert!(attributes.set_arrowhead("TEST"));
        assert!(attributes.unset_arrowhead());
    }

    #[test]
    fn arrowsize() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_arrowsize());
        assert!(attributes.set_arrowsize("TEST"));
        assert!(attributes.unset_arrowsize());
    }

    #[test]
    fn arrowtail() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_arrowtail());
        assert!(attributes.set_arrowtail("TEST"));
        assert!(attributes.unset_arrowtail());
    }

    #[test]
    fn class() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_class());
        assert!(attributes.set_class("TEST"));
        assert!(attributes.unset_class());
    }

    #[test]
    fn color() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_color());
        assert!(attributes.set_color("TEST"));
        assert!(attributes.unset_color());
    }

    #[test]
    fn colorscheme() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_colorscheme());
        assert!(attributes.set_colorscheme("TEST"));
        assert!(attributes.unset_colorscheme());
    }

    #[test]
    fn comment() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_comment());
        assert!(attributes.set_comment("TEST"));
        assert!(attributes.unset_comment());
    }

    #[test]
    fn constraint() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_constraint());
        assert!(attributes.set_constraint("TEST"));
        assert!(attributes.unset_constraint());
    }

    #[test]
    fn decorate() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_decorate());
        assert!(attributes.set_decorate("TEST"));
        assert!(attributes.unset_decorate());
    }

    #[test]
    fn dir() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_dir());
        assert!(attributes.set_dir("TEST"));
        assert!(attributes.unset_dir());
    }

    #[test]
    fn edgehref() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_edgehref());
        assert!(attributes.set_edgehref("TEST"));
        assert!(attributes.unset_edgehref());
    }

    #[test]
    fn edgetarget() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_edgetarget());
        assert!(attributes.set_edgetarget("TEST"));
        assert!(attributes.unset_edgetarget());
    }

    #[test]
    fn edgetooltip() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_edgetooltip());
        assert!(attributes.set_edgetooltip("TEST"));
        assert!(attributes.unset_edgetooltip());
    }

    #[test]
    fn edgeurl() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_edgeurl());
        assert!(attributes.set_edgeurl("TEST"));
        assert!(attributes.unset_edgeurl());
    }

    #[test]
    fn fillcolor() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_fillcolor());
        assert!(attributes.set_fillcolor("TEST"));
        assert!(attributes.unset_fillcolor());
    }

    #[test]
    fn fontcolor() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_fontcolor());
        assert!(attributes.set_fontcolor("TEST"));
        assert!(attributes.unset_fontcolor());
    }

    #[test]
    fn fontname() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_fontname());
        assert!(attributes.set_fontname("TEST"));
        assert!(attributes.unset_fontname());
    }

    #[test]
    fn fontsize() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_fontsize());
        assert!(attributes.set_fontsize("TEST"));
        assert!(attributes.unset_fontsize());
    }

    #[test]
    fn head_lp() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_head_lp());
        assert!(attributes.set_head_lp("TEST"));
        assert!(attributes.unset_head_lp());
    }

    #[test]
    fn headclip() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_headclip());
        assert!(attributes.set_headclip("TEST"));
        assert!(attributes.unset_headclip());
    }

    #[test]
    fn headhref() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_headhref());
        assert!(attributes.set_headhref("TEST"));
        assert!(attributes.unset_headhref());
    }

    #[test]
    fn headlabel() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_headlabel());
        assert!(attributes.set_headlabel("TEST"));
        assert!(attributes.unset_headlabel());
    }

    #[test]
    fn headport() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_headport());
        assert!(attributes.set_headport("TEST"));
        assert!(attributes.unset_headport());
    }

    #[test]
    fn headtarget() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_headtarget());
        assert!(attributes.set_headtarget("TEST"));
        assert!(attributes.unset_headtarget());
    }

    #[test]
    fn headtooltip() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_headtooltip());
        assert!(attributes.set_headtooltip("TEST"));
        assert!(attributes.unset_headtooltip());
    }

    #[test]
    fn headurl() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_headurl());
        assert!(attributes.set_headurl("TEST"));
        assert!(attributes.unset_headurl());
    }

    #[test]
    fn href() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_href());
        assert!(attributes.set_href("TEST"));
        assert!(attributes.unset_href());
    }

    #[test]
    fn id() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_id());
        assert!(attributes.set_id("TEST"));
        assert!(attributes.unset_id());
    }

    #[test]
    fn label() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_label());
        assert!(attributes.set_label("TEST"));
        assert!(attributes.unset_label());
    }

    #[test]
    fn labelangle() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labelangle());
        assert!(attributes.set_labelangle("TEST"));
        assert!(attributes.unset_labelangle());
    }

    #[test]
    fn labeldistance() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labeldistance());
        assert!(attributes.set_labeldistance("TEST"));
        assert!(attributes.unset_labeldistance());
    }

    #[test]
    fn labelfloat() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labelfloat());
        assert!(attributes.set_labelfloat("TEST"));
        assert!(attributes.unset_labelfloat());
    }

    #[test]
    fn labelfontcolor() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labelfontcolor());
        assert!(attributes.set_labelfontcolor("TEST"));
        assert!(attributes.unset_labelfontcolor());
    }

    #[test]
    fn labelfontname() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labelfontname());
        assert!(attributes.set_labelfontname("TEST"));
        assert!(attributes.unset_labelfontname());
    }

    #[test]
    fn labelfontsize() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labelfontsize());
        assert!(attributes.set_labelfontsize("TEST"));
        assert!(attributes.unset_labelfontsize());
    }

    #[test]
    fn labelhref() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labelhref());
        assert!(attributes.set_labelhref("TEST"));
        assert!(attributes.unset_labelhref());
    }

    #[test]
    fn labeltarget() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labeltarget());
        assert!(attributes.set_labeltarget("TEST"));
        assert!(attributes.unset_labeltarget());
    }

    #[test]
    fn labeltooltip() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labeltooltip());
        assert!(attributes.set_labeltooltip("TEST"));
        assert!(attributes.unset_labeltooltip());
    }

    #[test]
    fn labelurl() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_labelurl());
        assert!(attributes.set_labelurl("TEST"));
        assert!(attributes.unset_labelurl());
    }

    #[test]
    fn layer() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_layer());
        assert!(attributes.set_layer("TEST"));
        assert!(attributes.unset_layer());
    }

    #[test]
    fn len() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_len());
        assert!(attributes.set_len("TEST"));
        assert!(attributes.unset_len());
    }

    #[test]
    fn lhead() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_lhead());
        assert!(attributes.set_lhead("TEST"));
        assert!(attributes.unset_lhead());
    }

    #[test]
    fn lp() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_lp());
        assert!(attributes.set_lp("TEST"));
        assert!(attributes.unset_lp());
    }

    #[test]
    fn ltail() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_ltail());
        assert!(attributes.set_ltail("TEST"));
        assert!(attributes.unset_ltail());
    }

    #[test]
    fn minlen() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_minlen());
        assert!(attributes.set_minlen("TEST"));
        assert!(attributes.unset_minlen());
    }

    #[test]
    fn nojustify() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_nojustify());
        assert!(attributes.set_nojustify("TEST"));
        assert!(attributes.unset_nojustify());
    }

    #[test]
    fn penwidth() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_penwidth());
        assert!(attributes.set_penwidth("TEST"));
        assert!(attributes.unset_penwidth());
    }

    #[test]
    fn pos() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_pos());
        assert!(attributes.set_pos("TEST"));
        assert!(attributes.unset_pos());
    }

    #[test]
    fn samehead() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_samehead());
        assert!(attributes.set_samehead("TEST"));
        assert!(attributes.unset_samehead());
    }

    #[test]
    fn sametail() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_sametail());
        assert!(attributes.set_sametail("TEST"));
        assert!(attributes.unset_sametail());
    }

    #[test]
    fn showboxes() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_showboxes());
        assert!(attributes.set_showboxes("TEST"));
        assert!(attributes.unset_showboxes());
    }

    #[test]
    fn style() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_style());
        assert!(attributes.set_style("TEST"));
        assert!(attributes.unset_style());
    }

    #[test]
    fn tail_lp() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tail_lp());
        assert!(attributes.set_tail_lp("TEST"));
        assert!(attributes.unset_tail_lp());
    }

    #[test]
    fn tailclip() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tailclip());
        assert!(attributes.set_tailclip("TEST"));
        assert!(attributes.unset_tailclip());
    }

    #[test]
    fn tailhref() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tailhref());
        assert!(attributes.set_tailhref("TEST"));
        assert!(attributes.unset_tailhref());
    }

    #[test]
    fn taillabel() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_taillabel());
        assert!(attributes.set_taillabel("TEST"));
        assert!(attributes.unset_taillabel());
    }

    #[test]
    fn tailport() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tailport());
        assert!(attributes.set_tailport("TEST"));
        assert!(attributes.unset_tailport());
    }

    #[test]
    fn tailtarget() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tailtarget());
        assert!(attributes.set_tailtarget("TEST"));
        assert!(attributes.unset_tailtarget());
    }

    #[test]
    fn tailtooltip() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tailtooltip());
        assert!(attributes.set_tailtooltip("TEST"));
        assert!(attributes.unset_tailtooltip());
    }

    #[test]
    fn tailurl() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tailurl());
        assert!(attributes.set_tailurl("TEST"));
        assert!(attributes.unset_tailurl());
    }

    #[test]
    fn target() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_target());
        assert!(attributes.set_target("TEST"));
        assert!(attributes.unset_target());
    }

    #[test]
    fn tooltip() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_tooltip());
        assert!(attributes.set_tooltip("TEST"));
        assert!(attributes.unset_tooltip());
    }

    #[test]
    fn url() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_url());
        assert!(attributes.set_url("TEST"));
        assert!(attributes.unset_url());
    }

    #[test]
    fn weight() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_weight());
        assert!(attributes.set_weight("TEST"));
        assert!(attributes.unset_weight());
    }

    #[test]
    fn xlabel() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_xlabel());
        assert!(attributes.set_xlabel("TEST"));
        assert!(attributes.unset_xlabel());
    }

    #[test]
    fn xlp() {
        let mut attributes: EdgeAttributes = Default::default();
        assert!(!attributes.unset_xlp());
        assert!(attributes.set_xlp("TEST"));
        assert!(attributes.unset_xlp());
    }
}

mod subgraph_attributes {

    use causal_hub::io::dot::attributes::SubgraphAttributes;

    #[test]
    fn cluster() {
        let mut attributes: SubgraphAttributes = Default::default();
        assert!(!attributes.unset_cluster());
        assert!(attributes.set_cluster("TEST"));
        assert!(attributes.unset_cluster());
    }

    #[test]
    fn rank() {
        let mut attributes: SubgraphAttributes = Default::default();
        assert!(!attributes.unset_rank());
        assert!(attributes.set_rank("TEST"));
        assert!(attributes.unset_rank());
    }
}