test: 100% coverage for mfi + psar + cmf + hma + obv (#27)

* test(mfi): cover period accessor, name, flat-TP fallback

Codecov flagged 8 lines in indicators/mfi.rs (file at 93.10%): const
accessor period (58-60), (0.0, 0.0) arm when tp==prev (85), the
Some(50.0) flat-flow fallback (105), and Indicator-impl name body
(132-134). Add accessors_and_metadata and flat_typical_prices_default_to_50.
mfi.rs now at 116/116.

* test(psar): cover warmup/name, drop cold format-arg + panic-only asserts

Codecov flagged 8 lines in indicators/psar.rs (file at 95.69%):
warmup_period (206-208), name (220-222), the cold format-arg line
254 in pure_uptrend_sar_below_lows, and the in-loop assert! at line
275 in pure_downtrend_sar_above_highs (its panic body is dead).

Add accessors_and_metadata for warmup/name. Refactor both trend
tests to collect violations into a Vec and assert once outside the
loop — the single assert can now legitimately reach its panic body
in a regression, while removing the dead cold-path lines from the
happy-path coverage.

* test(cmf): cover period accessor, name, zero-range branch

Codecov flagged 7 lines in indicators/cmf.rs (file at 95.03%): const
accessor period (71-73), the range==0.0 zero-MFV branch (84), and
Indicator-impl name body (124-126). Add accessors_and_metadata and
zero_range_candle_contributes_zero_mfv (flat H=L=close candles).
cmf.rs now at 141/141.

* test(hma): cover period accessor + name, kill dead naive panic arm

Codecov flagged 7 lines in indicators/hma.rs (file at 92.22%): const
accessor period (51-53), Indicator-impl name body (87-89), and the
unreachable  arm at line 167 in matches_independent_wmas.
Refactor that test to assert the warmup-shape invariant via
assert_eq!(got.is_some(), want.is_some()) + if let, removing the
dead panic arm. Add accessors_and_metadata covering period/name.
hma.rs now at 90/90.

* test(obv): cover value() Some branch + warmup/name metadata

Codecov flagged 7 lines in indicators/obv.rs (file at 92.92%): the
Some(self.total) branch of value() (47) — only the None branch was
hit by reset_clears_state — plus Indicator-impl warmup_period
(79-81), name (87-89). Add accessors_and_metadata covering all four.
obv.rs now at 99/99.

crates/wickra-core/src/indicators/cmf.rs

@@ -214,6 +214,34 @@ mod tests {
         assert!(matches!(ChaikinMoneyFlow::new(0), Err(Error::PeriodZero)));
     }
 
+    /// Cover the const accessor `period` (71-73) and the Indicator-impl
+    /// `name` body (124-126). `warmup_period` is covered elsewhere.
+    #[test]
+    fn accessors_and_metadata() {
+        let cmf = ChaikinMoneyFlow::new(20).unwrap();
+        assert_eq!(cmf.period(), 20);
+        assert_eq!(cmf.name(), "CMF");
+    }
+
+    /// Cover the `range == 0.0` defensive branch (line 84). All other
+    /// tests use H != L candles; feed all-flat candles (H == L) so the
+    /// MFV computation must take the zero-range fallback and emit MFV = 0.
+    #[test]
+    fn zero_range_candle_contributes_zero_mfv() {
+        let mut cmf = ChaikinMoneyFlow::new(3).unwrap();
+        let candles: Vec<Candle> = (0..5)
+            .map(|i| Candle::new(10.0, 10.0, 10.0, 10.0, 5.0, i).unwrap())
+            .collect();
+        let last = cmf
+            .batch(&candles)
+            .into_iter()
+            .flatten()
+            .last()
+            .expect("emits");
+        // Every bar contributed 0 to mfv_sum, so the ratio is 0.
+        assert_eq!(last, 0.0);
+    }
+
     #[test]
     fn reset_clears_state() {
         let candles: Vec<Candle> = (0..20)

crates/wickra-core/src/indicators/hma.rs

@@ -128,6 +128,16 @@ mod tests {
         assert!(Hma::new(0).is_err());
     }
 
+    /// Cover the const accessor `period` (51-53) and the Indicator-impl
+    /// `name` body (87-89). `warmup_period` is covered by
+    /// `first_emission_matches_warmup_period`.
+    #[test]
+    fn accessors_and_metadata() {
+        let hma = Hma::new(9).unwrap();
+        assert_eq!(hma.period(), 9);
+        assert_eq!(hma.name(), "HMA");
+    }
+
     #[test]
     fn first_emission_matches_warmup_period() {
         let prices: Vec<f64> = (1..=40).map(f64::from).collect();
@@ -155,16 +165,16 @@ mod tests {
         let mut half = Wma::new(4).unwrap(); // (9 / 2).max(1)
         let mut full = Wma::new(9).unwrap();
         let mut smooth = Wma::new(3).unwrap(); // round(sqrt(9))
-        for &p in &prices {
+        for (i, &p) in prices.iter().enumerate() {
             let got = hma.update(p);
             let want = match (half.update(p), full.update(p)) {
                 (Some(h), Some(f)) => smooth.update(2.0 * h - f),
                 _ => None,
             };
-            match (got, want) {
-                (None, None) => {}
-                (Some(a), Some(b)) => assert_relative_eq!(a, b, epsilon = 1e-9),
-                _ => panic!("HMA and the independent-WMA reference disagree on readiness"),
+            // HMA and the independent WMA chain share a warmup formula.
+            assert_eq!(got.is_some(), want.is_some(), "readiness mismatch at {i}");
+            if let (Some(a), Some(b)) = (got, want) {
+                assert_relative_eq!(a, b, epsilon = 1e-9);
             }
         }
     }

crates/wickra-core/src/indicators/mfi.rs

@@ -181,6 +181,34 @@ mod tests {
         assert!(!mfi.is_ready());
     }
 
+    /// Cover the const accessor `period` (58-60) and the Indicator-impl
+    /// `name` body (132-134). `warmup_period` is already covered elsewhere.
+    #[test]
+    fn accessors_and_metadata() {
+        let mfi = Mfi::new(14).unwrap();
+        assert_eq!(mfi.period(), 14);
+        assert_eq!(mfi.name(), "MFI");
+    }
+
+    /// Cover the `tp == prev` arm (line 85) — when typical price equals
+    /// the previous typical price, both flows are 0 — and the all-zero-
+    /// flow fallback `Some(50.0)` (line 105). Existing tests use varying
+    /// candles so the flat-TP arm and the zero-flow fallback never fired.
+    #[test]
+    fn flat_typical_prices_default_to_50() {
+        let mut mfi = Mfi::new(3).unwrap();
+        let candles: Vec<Candle> = (0..6)
+            .map(|i| Candle::new(10.0, 10.0, 10.0, 10.0, 1.0, i).unwrap())
+            .collect();
+        let last = mfi
+            .batch(&candles)
+            .into_iter()
+            .flatten()
+            .last()
+            .expect("emits");
+        assert_eq!(last, 50.0);
+    }
+
     #[test]
     fn rejects_zero_period() {
         assert!(Mfi::new(0).is_err());

crates/wickra-core/src/indicators/obv.rs

@@ -99,6 +99,21 @@ mod tests {
         Candle::new(close, close, close, close, volume, 0).unwrap()
     }
 
+    /// Cover the `value()` Some branch (line 47) and the Indicator-impl
+    /// `warmup_period` (79-81) + `name` (87-89). `reset_clears_state`
+    /// hits only the None branch of `value()`; the metadata methods were
+    /// never queried.
+    #[test]
+    fn accessors_and_metadata() {
+        let mut obv = Obv::new();
+        assert_eq!(obv.warmup_period(), 1);
+        assert_eq!(obv.name(), "OBV");
+        assert_eq!(obv.value(), None);
+        obv.update(c(10.0, 100.0));
+        // Baseline 0 — value() Some branch.
+        assert_eq!(obv.value(), Some(0.0));
+    }
+
     #[test]
     fn first_candle_baseline_zero() {
         let mut obv = Obv::new();

crates/wickra-core/src/indicators/psar.rs

@@ -246,15 +246,21 @@ mod tests {
             })
             .collect();
         let mut psar = Psar::classic();
-        for (i, sar) in psar.batch(&candles).into_iter().enumerate() {
-            if let Some(s) = sar {
-                assert!(
-                    s <= candles[i].low + 1e-9,
-                    "SAR {s} should be <= low {} at i={i}",
-                    candles[i].low
-                );
-            }
-        }
+        let violations: Vec<(usize, f64, f64)> = psar
+            .batch(&candles)
+            .into_iter()
+            .enumerate()
+            .filter_map(|(i, sar)| {
+                sar.and_then(|s| {
+                    if s > candles[i].low + 1e-9 {
+                        Some((i, s, candles[i].low))
+                    } else {
+                        None
+                    }
+                })
+            })
+            .collect();
+        assert!(violations.is_empty(), "SAR above low: {violations:?}");
     }
 
     #[test]
@@ -267,13 +273,23 @@ mod tests {
             })
             .collect();
         let mut psar = Psar::classic();
-        let outs = psar.batch(&candles);
         // After the trend establishes downward, SAR should sit above highs.
-        for (i, sar) in outs.into_iter().enumerate().skip(5) {
-            if let Some(s) = sar {
-                assert!(s >= candles[i].high - 1e-9);
-            }
-        }
+        let violations: Vec<(usize, f64, f64)> = psar
+            .batch(&candles)
+            .into_iter()
+            .enumerate()
+            .skip(5)
+            .filter_map(|(i, sar)| {
+                sar.and_then(|s| {
+                    if s < candles[i].high - 1e-9 {
+                        Some((i, s, candles[i].high))
+                    } else {
+                        None
+                    }
+                })
+            })
+            .collect();
+        assert!(violations.is_empty(), "SAR below high: {violations:?}");
     }
 
     #[test]
@@ -292,6 +308,16 @@ mod tests {
         );
     }
 
+    /// Cover the Indicator-impl `warmup_period` (206-208) and `name`
+    /// (220-222). PSAR's warmup is the constant 2 (seed candle + first
+    /// emitting candle); the name is the literal "PSAR".
+    #[test]
+    fn accessors_and_metadata() {
+        let psar = Psar::classic();
+        assert_eq!(psar.warmup_period(), 2);
+        assert_eq!(psar.name(), "PSAR");
+    }
+
     #[test]
     fn rejects_invalid_params() {
         assert!(Psar::new(0.0, 0.02, 0.20).is_err());