pyrograph 0.1.0

#![cfg(feature = "rust-lang")]
use pyrograph::analyze;


#[test]
fn test_batch35_001() {
    let code = include_str!("../corpus/rust/malware/batch35_001.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_001.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_001.rs");
}


#[test]
fn test_batch35_002() {
    let code = include_str!("../corpus/rust/malware/batch35_002.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_002.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_002.rs");
}


#[test]
fn test_batch35_003() {
    let code = include_str!("../corpus/rust/malware/batch35_003.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_003.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_003.rs");
}


#[test]
fn test_batch35_004() {
    let code = include_str!("../corpus/rust/malware/batch35_004.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_004.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_004.rs");
}


#[test]
fn test_batch35_005() {
    let code = include_str!("../corpus/rust/malware/batch35_005.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_005.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_005.rs");
}


#[test]
fn test_batch35_006() {
    let code = include_str!("../corpus/rust/malware/batch35_006.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_006.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_006.rs");
}


#[test]
fn test_batch35_007() {
    let code = include_str!("../corpus/rust/malware/batch35_007.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_007.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_007.rs");
}


#[test]
fn test_batch35_008() {
    let code = include_str!("../corpus/rust/malware/batch35_008.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_008.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_008.rs");
}


#[test]
fn test_batch35_009() {
    let code = include_str!("../corpus/rust/malware/batch35_009.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_009.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_009.rs");
}


#[test]
fn test_batch35_010() {
    let code = include_str!("../corpus/rust/malware/batch35_010.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_010.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_010.rs");
}


#[test]
fn test_batch35_011() {
    let code = include_str!("../corpus/rust/malware/batch35_011.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_011.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_011.rs");
}


#[test]
fn test_batch35_012() {
    let code = include_str!("../corpus/rust/malware/batch35_012.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_012.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_012.rs");
}


#[test]
fn test_batch35_013() {
    let code = include_str!("../corpus/rust/malware/batch35_013.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_013.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_013.rs");
}


#[test]
fn test_batch35_014() {
    let code = include_str!("../corpus/rust/malware/batch35_014.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_014.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_014.rs");
}


#[test]
fn test_batch35_015() {
    let code = include_str!("../corpus/rust/malware/batch35_015.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_015.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_015.rs");
}


#[test]
fn test_batch35_016() {
    let code = include_str!("../corpus/rust/malware/batch35_016.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_016.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_016.rs");
}


#[test]
fn test_batch35_017() {
    let code = include_str!("../corpus/rust/malware/batch35_017.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_017.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_017.rs");
}


#[test]
fn test_batch35_018() {
    let code = include_str!("../corpus/rust/malware/batch35_018.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_018.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_018.rs");
}


#[test]
fn test_batch35_019() {
    let code = include_str!("../corpus/rust/malware/batch35_019.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_019.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_019.rs");
}


#[test]
fn test_batch35_020() {
    let code = include_str!("../corpus/rust/malware/batch35_020.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_020.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_020.rs");
}


#[test]
fn test_batch35_021() {
    let code = include_str!("../corpus/rust/malware/batch35_021.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_021.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_021.rs");
}


#[test]
fn test_batch35_022() {
    let code = include_str!("../corpus/rust/malware/batch35_022.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_022.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_022.rs");
}


#[test]
fn test_batch35_023() {
    let code = include_str!("../corpus/rust/malware/batch35_023.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_023.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_023.rs");
}


#[test]
fn test_batch35_024() {
    let code = include_str!("../corpus/rust/malware/batch35_024.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_024.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_024.rs");
}


#[test]
fn test_batch35_025() {
    let code = include_str!("../corpus/rust/malware/batch35_025.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_025.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_025.rs");
}


#[test]
fn test_batch35_026() {
    let code = include_str!("../corpus/rust/malware/batch35_026.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_026.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_026.rs");
}


#[test]
fn test_batch35_027() {
    let code = include_str!("../corpus/rust/malware/batch35_027.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_027.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_027.rs");
}


#[test]
fn test_batch35_028() {
    let code = include_str!("../corpus/rust/malware/batch35_028.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_028.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_028.rs");
}


#[test]
fn test_batch35_029() {
    let code = include_str!("../corpus/rust/malware/batch35_029.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_029.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_029.rs");
}


#[test]
fn test_batch35_030() {
    let code = include_str!("../corpus/rust/malware/batch35_030.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_030.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_030.rs");
}


#[test]
fn test_batch35_031() {
    let code = include_str!("../corpus/rust/malware/batch35_031.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_031.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_031.rs");
}


#[test]
fn test_batch35_032() {
    let code = include_str!("../corpus/rust/malware/batch35_032.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_032.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_032.rs");
}


#[test]
fn test_batch35_033() {
    let code = include_str!("../corpus/rust/malware/batch35_033.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_033.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_033.rs");
}


#[test]
fn test_batch35_034() {
    let code = include_str!("../corpus/rust/malware/batch35_034.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_034.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_034.rs");
}


#[test]
fn test_batch35_035() {
    let code = include_str!("../corpus/rust/malware/batch35_035.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_035.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_035.rs");
}


#[test]
fn test_batch35_036() {
    let code = include_str!("../corpus/rust/malware/batch35_036.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_036.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_036.rs");
}


#[test]
fn test_batch35_037() {
    let code = include_str!("../corpus/rust/malware/batch35_037.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_037.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_037.rs");
}


#[test]
fn test_batch35_038() {
    let code = include_str!("../corpus/rust/malware/batch35_038.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_038.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_038.rs");
}


#[test]
fn test_batch35_039() {
    let code = include_str!("../corpus/rust/malware/batch35_039.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_039.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_039.rs");
}


#[test]
fn test_batch35_040() {
    let code = include_str!("../corpus/rust/malware/batch35_040.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_040.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_040.rs");
}


#[test]
fn test_batch35_041() {
    let code = include_str!("../corpus/rust/malware/batch35_041.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_041.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_041.rs");
}


#[test]
fn test_batch35_042() {
    let code = include_str!("../corpus/rust/malware/batch35_042.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_042.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_042.rs");
}


#[test]
fn test_batch35_043() {
    let code = include_str!("../corpus/rust/malware/batch35_043.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_043.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_043.rs");
}


#[test]
fn test_batch35_044() {
    let code = include_str!("../corpus/rust/malware/batch35_044.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_044.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_044.rs");
}


#[test]
fn test_batch35_045() {
    let code = include_str!("../corpus/rust/malware/batch35_045.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_045.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_045.rs");
}


#[test]
fn test_batch35_046() {
    let code = include_str!("../corpus/rust/malware/batch35_046.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_046.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_046.rs");
}


#[test]
fn test_batch35_047() {
    let code = include_str!("../corpus/rust/malware/batch35_047.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_047.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_047.rs");
}


#[test]
fn test_batch35_048() {
    let code = include_str!("../corpus/rust/malware/batch35_048.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_048.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_048.rs");
}


#[test]
fn test_batch35_049() {
    let code = include_str!("../corpus/rust/malware/batch35_049.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_049.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_049.rs");
}


#[test]
fn test_batch35_050() {
    let code = include_str!("../corpus/rust/malware/batch35_050.rs");
    let g = pyrograph::parse::rust::parse_rust_with_labels(code, "batch35_050.rs", None).unwrap();
    let f = analyze(&g).unwrap();
    assert!(!f.is_empty(), "must detect mixed attack chain in batch35_050.rs");
}