kestrel-chartkit 0.11.3

High-performance Rust technical analysis library for indicator math, market regime classification, composite scoring, and SVG visualization.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

mod common;

use common::*;
use kestrel_chartkit::indicator::registry::{build, catalog};

#[test]
fn test_all_indicators_short_series_no_panic() {
    let entries = catalog();
    for entry in &entries {
        let mut indicator = build(entry.name, &entry.default_params)
            .unwrap_or_else(|| panic!("Failed to build indicator {}", entry.name));

        let short_bars = generate_flat_spread_bars(5, 100.0, 1.0, 1000.0);
        assert_no_panic(indicator.as_mut(), &short_bars);
    }
}

#[test]
fn test_all_indicators_flatline_data_no_panic() {
    let entries = catalog();
    for entry in &entries {
        let mut indicator = build(entry.name, &entry.default_params)
            .unwrap_or_else(|| panic!("Failed to build indicator {}", entry.name));

        let flat_bars = generate_flat_spread_bars(200, 100.0, 0.0, 1000.0);
        assert_no_panic(indicator.as_mut(), &flat_bars);
    }
}

#[test]
fn test_all_indicators_zero_volume_no_panic() {
    let entries = catalog();
    for entry in &entries {
        let mut indicator = build(entry.name, &entry.default_params)
            .unwrap_or_else(|| panic!("Failed to build indicator {}", entry.name));

        let zero_vol_bars = generate_zero_volume_bars(200, 100.0);
        assert_no_panic(indicator.as_mut(), &zero_vol_bars);
    }
}

#[test]
fn test_all_indicators_nan_robustness_no_panic() {
    let entries = catalog();
    for entry in &entries {
        let mut indicator = build(entry.name, &entry.default_params)
            .unwrap_or_else(|| panic!("Failed to build indicator {}", entry.name));

        let nan_bars = generate_nan_bars(100);
        assert_no_panic(indicator.as_mut(), &nan_bars);
    }
}

#[test]
fn test_all_indicators_warmup_contract() {
    let entries = catalog();
    for entry in &entries {
        let mut indicator = build(entry.name, &entry.default_params)
            .unwrap_or_else(|| panic!("Failed to build indicator {}", entry.name));

        let warmup = indicator.warmup_period();
        let bars = generate_sine_bars(warmup + 100, 100.0, 10.0, 20.0, 1000.0);

        let outputs = run_indicator(indicator.as_mut(), &bars);

        // After warmup period, output should be Some(IndicatorOutput)
        if warmup < outputs.len() {
            let post_warmup_outputs = &outputs[warmup..];
            for (idx, out) in post_warmup_outputs.iter().enumerate() {
                assert!(
                    out.is_some(),
                    "Indicator {} produced None at bar {} after warmup period {}",
                    entry.name,
                    warmup + idx,
                    warmup
                );
            }
        }
    }
}

#[test]
fn test_all_indicators_random_walk_fuzzing_no_panic() {
    let entries = catalog();
    // Test across multiple deterministic random walk seeds with varying drift and volatility
    for seed in [1, 42, 101, 777, 9999] {
        let bars = generate_random_walk_bars(seed, 120, 100.0, 0.05, 1.5, 1000.0);
        for entry in &entries {
            let mut indicator = build(entry.name, &entry.default_params)
                .unwrap_or_else(|| panic!("Failed to build indicator {}", entry.name));
            assert_no_panic(indicator.as_mut(), &bars);
        }
    }
}

#[test]
fn test_all_indicators_trending_fuzzing_no_panic() {
    let entries = catalog();
    // Test across strong uptrends and downtrends with noise
    for (trend_step, noise) in [(1.5, 0.3), (-1.5, 0.3)] {
        let bars = generate_trending_bars(42, 120, 100.0, trend_step, noise, 1000.0);
        for entry in &entries {
            let mut indicator = build(entry.name, &entry.default_params)
                .unwrap_or_else(|| panic!("Failed to build indicator {}", entry.name));
            assert_no_panic(indicator.as_mut(), &bars);
        }
    }
}