automapper_validation/eval/

abrechnungsdaten.rs

//! The products of chapter 6.2 of the Codeliste der Konfigurationen,
//! "Produkte zur Bestellung einer Änderung von Abrechnungsdaten": what an
//! ORDERS 17133 may order in PIA+5 DE7140, and what each product takes in its
//! SG30 — a Produkteigenschaft (CAV+ZH9 DE7110) from its own list, or a
//! Wertedetail (CAV+ZV4 DE7110) of its own format.
//!
//! The AHB conditions reading it: `[158]` (the product is one of them),
//! `[159]` (it has Produkteigenschaften), `[160]` (the CAV+ZH9 code is one of
//! its own), `[162]` (the CAV+ZV4 value fits its format) and `[180]` (it has a
//! Wertedetail). Bilanzkreis takes an EIC (`[970]` an..17),
//! Jahresverbrauchsprognose a whole number (`[909]` ∧ `[937]`).
//!
//! Chapter 6.1, "Produkte zur Anmeldung einer Zuordnung des LFN (UTILMD)",
//! has the same columns for the Anmeldungen (55001, 55077, 55014, ...: SG8
//! SEQ+Z79 PIA+5, SG10 CAV+ZH9 / CAV+ZV4, `[292]`, `[36]`, `[38]`, `[39]`,
//! `[40]`) and is [`AbrechnungsdatenProdukte::anmeldung`]. It adds the
//! Prüfidentifikatoren that may order each product (the Bilanzkreis, which
//! every Produktpaket must name, is the one product 55014 may order), how often
//! one may stand in a Produktpaket, and Wertedetails needed only beside one
//! Produkteigenschaft (Tranchengröße: a share beside `9991000003014`, in 1.4 a
//! TR-ID beside `9991000003220`).
//!
//! Data source: the Codeliste's .docx editions, extracted with
//! `scripts/extract_konfigurationen_abrechnungsdaten.py` (`--chapter 6.1` for
//! `konfigurationen_anmeldung.json`). FV2504 to FV2604 read version 1.3c,
//! FV2610 version 1.4 (which adds spezifische Arbeit to 6.2 and the
//! Ausschluss products to 6.1).

use serde::Deserialize;
use std::collections::HashMap;
use std::sync::OnceLock;

use super::{ConditionResult, EvaluationContext};
use crate::eval::format_validators::{
    is_edifact_number, validate_max_decimal_places, validate_numeric,
    validate_technische_ressource_id,
};

const EMBEDDED_JSON: &str = include_str!("../../data/konfigurationen_abrechnungsdaten.json");
const ANMELDUNG_JSON: &str = include_str!("../../data/konfigurationen_anmeldung.json");

/// The edition of the Codeliste der Konfigurationen a format version reads.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Edition {
    /// Version 1.3c: FV2504, FV2510, FV2604.
    V1_3c,
    /// Version 1.4: FV2610.
    V1_4,
}

impl Edition {
    /// The edition `fv` reads; `None` for a format version before FV2504.
    pub fn of_format_version(fv: &str) -> Option<Self> {
        match fv {
            "FV2504" | "FV2510" | "FV2604" => Some(Self::V1_3c),
            "FV2610" => Some(Self::V1_4),
            _ => None,
        }
    }

    fn key(self) -> &'static str {
        match self {
            Self::V1_3c => "1.3c",
            Self::V1_4 => "1.4",
        }
    }
}

#[derive(Debug, Deserialize)]
struct RawFile {
    versions: HashMap<String, RawVersion>,
}

#[derive(Debug, Deserialize)]
struct RawVersion {
    products: Vec<Product>,
}

/// One product of chapter 6.2 or 6.1.
#[derive(Debug, Deserialize)]
pub struct Product {
    /// The product code, PIA+5 DE7140.
    pub code: String,
    pub name: String,
    /// The codes its CAV+ZH9 DE7110 may carry; empty when it has none.
    pub property_codes: Vec<PropertyCode>,
    /// What its CAV+ZV4 DE7110 carries; `None` when it has none.
    pub wertedetails: Option<Wertedetails>,
    /// The Prüfidentifikatoren that may order it.
    #[serde(default)]
    pub pids: Vec<String>,
    /// The subchapter listing it (`6.1.1`); `None` in a chapter without.
    #[serde(default)]
    pub chapter: Option<String>,
    /// How often it may stand in one Produktpaket (6.1 only).
    #[serde(default)]
    pub max_repetitions: Option<u32>,
}

impl Product {
    /// Whether `pid` may order it. True when the table names no
    /// Prüfidentifikator.
    pub fn orderable_by(&self, pid: &str) -> bool {
        self.pids.is_empty() || self.pids.iter().any(|p| p == pid)
    }
}

#[derive(Debug, Deserialize)]
pub struct PropertyCode {
    pub code: String,
    pub name: String,
}

/// A product's Wertedetail: its name and the format conditions its value
/// must hold (`[970]`).
#[derive(Debug, Deserialize)]
pub struct Wertedetails {
    pub name: String,
    pub conditions: Vec<u32>,
    /// Where the Wertedetail is needed only beside a Produkteigenschaft, one
    /// entry per such code with the formats its value then holds. Empty when
    /// it stands beside any (or none).
    #[serde(default)]
    pub variants: Vec<WertedetailsVariant>,
}

/// The Wertedetail beside one Produkteigenschaft.
#[derive(Debug, Deserialize)]
pub struct WertedetailsVariant {
    pub with_property: String,
    pub conditions: Vec<u32>,
}

/// A valid EIC of a Bilanzkreis (`11X...`, check character included), for a
/// sample's Wertedetail.
pub const EXAMPLE_BILANZKREIS: &str = "11XBILANZKREIS-O";

impl Wertedetails {
    /// Whether `value` holds the format conditions: those of the variant
    /// beside `property` where the Wertedetail has variants (any variant's
    /// when `property` is `None` or none matches), else all of them. Unknown
    /// for a condition the table names but this code does not know.
    pub fn fits_beside(&self, value: &str, property: Option<&str>) -> ConditionResult {
        if self.variants.is_empty() {
            return holds(&self.conditions, value);
        }
        if let Some(v) = self
            .variants
            .iter()
            .find(|v| Some(v.with_property.as_str()) == property)
        {
            return holds(&v.conditions, value);
        }
        let results = self.variants.iter().map(|v| holds(&v.conditions, value));
        results.fold(ConditionResult::False, |best, r| match (best, r) {
            (ConditionResult::True, _) | (_, ConditionResult::True) => ConditionResult::True,
            (ConditionResult::Unknown, _) | (_, ConditionResult::Unknown) => {
                ConditionResult::Unknown
            }
            _ => ConditionResult::False,
        })
    }

    /// Whether `value` holds the format conditions, beside any
    /// Produkteigenschaft.
    pub fn fits(&self, value: &str) -> ConditionResult {
        self.fits_beside(value, None)
    }

    /// Whether the Wertedetail is needed beside `property` (the product's
    /// CAV+ZH9 code, `None` without one): always, unless it is tied to other
    /// Produkteigenschaften.
    pub fn needed_beside(&self, property: Option<&str>) -> bool {
        self.variants.is_empty()
            || self
                .variants
                .iter()
                .any(|v| Some(v.with_property.as_str()) == property)
    }

    /// Whether `value` is what a sample should carry beside `property`: it
    /// holds the formats, and a Bilanzkreis (`[970]`, which says only
    /// an..17) is an EIC.
    pub fn suits_sample(&self, value: &str, property: Option<&str>) -> bool {
        self.fits_beside(value, property) == ConditionResult::True
            && (!self.conditions.contains(&970) || is_eic(value))
    }

    /// A value holding the formats beside `property`, for a sample: a
    /// Bilanzkreis EIC, a TR-ID, a whole number, a share. `None` when none
    /// of these does.
    pub fn example_value(&self, property: Option<&str>) -> Option<&'static str> {
        [EXAMPLE_BILANZKREIS, "D1234567890", "4000", "50", "1.125"]
            .into_iter()
            .filter(|v| !self.conditions.contains(&970) || *v == EXAMPLE_BILANZKREIS)
            .find(|v| self.fits_beside(v, property) == ConditionResult::True)
    }
}

/// Whether `value` is an Energy Identification Code: 16 characters of
/// digits, capitals and `-`, the last the check character of the first 15
/// (weights 16 down to 2, modulo 37).
pub fn is_eic(value: &str) -> bool {
    let digit = |c: char| match c {
        '0'..='9' => Some(c as u32 - '0' as u32),
        'A'..='Z' => Some(c as u32 - 'A' as u32 + 10),
        '-' => Some(36),
        _ => None,
    };
    let Some(digits) = value.chars().map(digit).collect::<Option<Vec<u32>>>() else {
        return false;
    };
    if digits.len() != 16 {
        return false;
    }
    let sum: u32 = digits[..15]
        .iter()
        .enumerate()
        .map(|(i, d)| d * (16 - i as u32))
        .sum();
    let check = 36 - (sum + 36) % 37;
    check != 36 && digits[15] == check
}

/// Whether `value` holds every format condition of `conditions`.
fn holds(conditions: &[u32], value: &str) -> ConditionResult {
    let mut result = ConditionResult::True;
    for condition in conditions {
        let holds = match condition {
            // Format: an..17
            970 => ConditionResult::from(value.chars().count() <= 17),
            // Format: Mögliche Werte: 0 bis n
            909 => ConditionResult::from(
                is_edifact_number(value) && !value.trim_start().starts_with('-'),
            ),
            // Format: keine Nachkommastelle
            937 => ConditionResult::from(is_edifact_number(value) && !value.contains(['.', ','])),
            // Format: max. 3 Nachkommastellen
            906 => validate_max_decimal_places(value, 3),
            // Format: Möglicher Wert: > 0
            914 => validate_numeric(value, ">", 0.0),
            // Format: TR-ID
            922 => validate_technische_ressource_id(value),
            // Format: max. 2 Nachkommastellen
            930 => validate_max_decimal_places(value, 2),
            // Format: Möglicher Wert: < 100
            955 => validate_numeric(value, "<", 100.0),
            _ => ConditionResult::Unknown,
        };
        match holds {
            ConditionResult::False => return ConditionResult::False,
            ConditionResult::Unknown => result = ConditionResult::Unknown,
            ConditionResult::True => {}
        }
    }
    result
}

/// Chapter 6.2 (or 6.1) in every edition the format versions read.
#[derive(Debug)]
pub struct AbrechnungsdatenProdukte {
    editions: HashMap<String, Vec<Product>>,
}

impl AbrechnungsdatenProdukte {
    pub fn from_json(json: &str) -> Result<Self, serde_json::Error> {
        let raw: RawFile = serde_json::from_str(json)?;
        Ok(Self {
            editions: raw
                .versions
                .into_iter()
                .map(|(version, v)| (version, v.products))
                .collect(),
        })
    }

    pub fn embedded() -> &'static Self {
        static CELL: OnceLock<AbrechnungsdatenProdukte> = OnceLock::new();
        CELL.get_or_init(|| {
            AbrechnungsdatenProdukte::from_json(EMBEDDED_JSON)
                .expect("embedded konfigurationen_abrechnungsdaten.json is malformed")
        })
    }

    /// Chapter 6.1, the products of the UTILMD Anmeldungen.
    pub fn anmeldung() -> &'static Self {
        static CELL: OnceLock<AbrechnungsdatenProdukte> = OnceLock::new();
        CELL.get_or_init(|| {
            AbrechnungsdatenProdukte::from_json(ANMELDUNG_JSON)
                .expect("embedded konfigurationen_anmeldung.json is malformed")
        })
    }

    /// The products of `edition`, in the table's order.
    pub fn products(&self, edition: Edition) -> &[Product] {
        self.editions
            .get(edition.key())
            .map_or(&[], |products| products.as_slice())
    }

    /// The product `code` of `edition`, if the table lists it.
    pub fn product(&self, edition: Edition, code: &str) -> Option<&Product> {
        self.products(edition).iter().find(|p| p.code == code)
    }
}

/// The product `code` of chapter 6.1 or 6.2 of `edition`, if either lists
/// it. Their codes are apart (the Bilanzkreis is `9991000002082` in 6.1,
/// `9991000002553` in 6.2).
pub fn chapter6_product(edition: Edition, code: &str) -> Option<&'static Product> {
    AbrechnungsdatenProdukte::anmeldung()
        .product(edition, code)
        .or_else(|| AbrechnungsdatenProdukte::embedded().product(edition, code))
}

/// The product code ordered in PIA+5 DE7140 of the SG29 the field sits in,
/// or of the message's first PIA+5 without a scope (17133 sends one SG29,
/// `[2050]`). `None` when there is none.
fn ordered_product(ctx: &EvaluationContext) -> Option<String> {
    ctx.scoped_find_segments_in("SG29", "PIA")
        .into_iter()
        .find(|s| s.get_element(0) == "5")
        .and_then(|s| s.elements.get(1)?.first().cloned())
        .filter(|code| !code.is_empty())
}

/// What `answer` makes of the ordered product: Unknown when there is none,
/// False for a product the table does not list.
fn of_product(
    ctx: &EvaluationContext,
    edition: Edition,
    answer: impl Fn(&Product) -> ConditionResult,
) -> ConditionResult {
    let Some(code) = ordered_product(ctx) else {
        return ConditionResult::Unknown;
    };
    match AbrechnungsdatenProdukte::embedded().product(edition, &code) {
        Some(product) => answer(product),
        None => ConditionResult::False,
    }
}

/// `[158]` Es sind nur die Produkt-Codes erlaubt, die in Kapitel 6.2 genannt
/// sind: judged on the element's own value (PIA+5 DE7140), else on the
/// ordered product.
pub fn product_is_listed(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    let code = match ctx.resolved_value {
        Some(value) => value.to_string(),
        None => match ordered_product(ctx) {
            Some(code) => code,
            None => return ConditionResult::Unknown,
        },
    };
    ConditionResult::from(
        AbrechnungsdatenProdukte::embedded()
            .product(edition, &code)
            .is_some(),
    )
}

/// `[159]` Wenn der Produkt-Code in der Spalte "Code der Produkteigenschaft"
/// mit einem Code befüllt ist.
pub fn has_property_codes(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    of_product(ctx, edition, |p| {
        ConditionResult::from(!p.property_codes.is_empty())
    })
}

/// `[160]` Nur die Codes der Produkteigenschaft des Produkts: the value of
/// CAV+ZH9 DE7110 is one of its codes.
pub fn property_code_allowed(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    let Some(value) = ctx.resolved_value else {
        return ConditionResult::Unknown;
    };
    of_product(ctx, edition, |p| {
        ConditionResult::from(p.property_codes.iter().any(|c| c.code == value))
    })
}

/// `[162]` Nur der Wertebereich der Spalte "Wertedetails für Position": the
/// value of CAV+ZV4 DE7110 holds the product's format conditions. False for a
/// product without a Wertedetail.
pub fn wertedetails_value_fits(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    let Some(value) = ctx.resolved_value else {
        return ConditionResult::Unknown;
    };
    of_product(ctx, edition, |p| match &p.wertedetails {
        Some(w) => w.fits(value),
        None => ConditionResult::False,
    })
}

/// `[180]` Wenn der Produkt-Code in der Spalte "Wertedetails für Position"
/// eine Angabe hat, deren ggf. enthaltene Bedingung erfüllt ist. The
/// Bedingungen there are the value's formats, which `[162]` beside it judges;
/// here, that the product has a Wertedetail.
pub fn has_wertedetails(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    of_product(ctx, edition, |p| {
        ConditionResult::from(p.wertedetails.is_some())
    })
}

/// The product of the SG8 SEQ+Z79 the field sits in: its PIA+5 DE7140 beside
/// DE7143 `Z11`. Without a scope, the message's one such product; `None` when
/// there is none, or several without a scope to choose.
fn anmeldung_product(ctx: &EvaluationContext) -> Option<String> {
    let mut codes: Vec<String> = ctx
        .scoped_find_segments_in("SG8", "PIA")
        .into_iter()
        .filter(|s| s.get_element(0) == "5" && s.get_component(1, 1) == "Z11")
        .filter_map(|s| s.elements.get(1)?.first().cloned())
        .filter(|code| !code.is_empty())
        .collect();
    codes.dedup();
    match codes.as_slice() {
        [one] => Some(one.clone()),
        _ => None,
    }
}

/// The Produkteigenschaft of the same SG8 (SG10 CAV+ZH9 DE7110), if one is
/// sent.
fn anmeldung_property(ctx: &EvaluationContext) -> Option<String> {
    ctx.scoped_find_segments_in("SG8", "CAV")
        .into_iter()
        .find(|s| s.get_component(0, 0) == "ZH9")
        .map(|s| s.get_component(0, 3).to_string())
        .filter(|code| !code.is_empty())
}

/// What `answer` makes of the SG8's product in chapter 6.1: Unknown when there
/// is none, False for a product the chapter does not list.
fn of_anmeldung_product(
    ctx: &EvaluationContext,
    edition: Edition,
    answer: impl Fn(&Product) -> ConditionResult,
) -> ConditionResult {
    let Some(code) = anmeldung_product(ctx) else {
        return ConditionResult::Unknown;
    };
    match AbrechnungsdatenProdukte::anmeldung().product(edition, &code) {
        Some(product) => answer(product),
        None => ConditionResult::False,
    }
}

/// UTILMD `[292]` Es sind nur die Produkt-Codes erlaubt, die in Kapitel 6.1
/// mit dem Prüfidentifikator des Anwendungsfalls gekennzeichnet sind: judged
/// on the element's own value (PIA+5 DE7140), else on the SG8's product. A
/// Prüfidentifikator no row names (FV2610 55003, the Ablehnung naming the
/// products of the Anmeldung it refuses) may name any product of the chapter.
pub fn anmeldung_product_allowed(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    let code = match ctx.resolved_value {
        Some(value) => value.to_string(),
        None => match anmeldung_product(ctx) {
            Some(code) => code,
            None => return ConditionResult::Unknown,
        },
    };
    let table = AbrechnungsdatenProdukte::anmeldung().products(edition);
    let pid = ctx.pruefidentifikator;
    let named = table.iter().any(|p| p.pids.iter().any(|q| q == pid));
    ConditionResult::from(
        table
            .iter()
            .any(|p| p.code == code && (!named || p.orderable_by(pid))),
    )
}

/// UTILMD `[36]` Wenn der Produkt-Code derselben SG8 in Kapitel 6.1 in der
/// Spalte "Code der Produkteigenschaft" mit einem Code befüllt ist.
pub fn anmeldung_has_property_codes(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    of_anmeldung_product(ctx, edition, |p| {
        ConditionResult::from(!p.property_codes.is_empty())
    })
}

/// UTILMD `[38]` Nur die Codes der Produkteigenschaft des Produkts derselben
/// SG8: the value of CAV+ZH9 DE7110 is one of them.
pub fn anmeldung_property_code_allowed(
    ctx: &EvaluationContext,
    edition: Edition,
) -> ConditionResult {
    let Some(value) = ctx.resolved_value else {
        return ConditionResult::Unknown;
    };
    of_anmeldung_product(ctx, edition, |p| {
        ConditionResult::from(p.property_codes.iter().any(|c| c.code == value))
    })
}

/// UTILMD `[39]` Wenn der Produkt-Code derselben SG8 in Kapitel 6.1 in der
/// Spalte "Wertedetails für Position" eine Angabe hat, deren ggf. enthaltene
/// Bedingung erfüllt ist: that the product has a Wertedetail, and where it is
/// needed only beside a Produkteigenschaft (Tranchengröße), that the SG8's
/// CAV+ZH9 names it.
pub fn anmeldung_has_wertedetails(ctx: &EvaluationContext, edition: Edition) -> ConditionResult {
    let property = anmeldung_property(ctx);
    of_anmeldung_product(ctx, edition, |p| {
        ConditionResult::from(
            p.wertedetails
                .as_ref()
                .is_some_and(|w| w.needed_beside(property.as_deref())),
        )
    })
}

/// UTILMD `[40]` Nur der Wertebereich der Spalte "Wertedetails für Position":
/// the value of CAV+ZV4 DE7110 holds the formats of the product's Wertedetail
/// beside the SG8's Produkteigenschaft. False for a product without one.
pub fn anmeldung_wertedetails_value_fits(
    ctx: &EvaluationContext,
    edition: Edition,
) -> ConditionResult {
    let Some(value) = ctx.resolved_value else {
        return ConditionResult::Unknown;
    };
    let property = anmeldung_property(ctx);
    of_anmeldung_product(ctx, edition, |p| match &p.wertedetails {
        Some(w) => w.fits_beside(value, property.as_deref()),
        None => ConditionResult::False,
    })
}

/// Values that satisfy the ORDERS `condition` of `fv` for some product of
/// chapter 6.2 — every product code for `[158]`, every Produkteigenschaft for
/// `[160]` — for a sample generator to offer an element the condition judges.
/// Empty for any other condition or message type.
pub fn candidate_values(message_type: &str, fv: &str, condition: u32) -> Vec<String> {
    let Some(edition) = Edition::of_format_version(fv).filter(|_| message_type == "ORDERS") else {
        return Vec::new();
    };
    let products = AbrechnungsdatenProdukte::embedded().products(edition);
    match condition {
        158 => products.iter().map(|p| p.code.clone()).collect(),
        160 => products
            .iter()
            .flat_map(|p| p.property_codes.iter().map(|c| c.code.clone()))
            .collect(),
        _ => Vec::new(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn both_editions_load() {
        let table = AbrechnungsdatenProdukte::embedded();
        assert_eq!(table.products(Edition::V1_3c).len(), 9);
        assert_eq!(table.products(Edition::V1_4).len(), 10);
        assert!(table.product(Edition::V1_3c, "9991000003246").is_none());
        let arbeit = table.product(Edition::V1_4, "9991000003246").expect("1.4");
        assert_eq!(arbeit.name, "spezifische Arbeit");
    }

    #[test]
    fn wertedetails_hold_their_formats() {
        let table = AbrechnungsdatenProdukte::embedded();
        let w = |code: &str| {
            table
                .product(Edition::V1_4, code)
                .and_then(|p| p.wertedetails.as_ref())
                .expect("a Wertedetail")
        };
        let bilanzkreis = w("9991000002553");
        assert_eq!(bilanzkreis.fits("11XLIEFERANT2--E"), ConditionResult::True);
        assert_eq!(
            bilanzkreis.fits("11XLIEFERANT2--E-TOO-LONG"),
            ConditionResult::False
        );
        let prognose = w("9991000002561");
        assert_eq!(prognose.fits("4000"), ConditionResult::True);
        assert_eq!(prognose.fits("4000.5"), ConditionResult::False);
        assert_eq!(prognose.fits("-1"), ConditionResult::False);
        assert_eq!(prognose.fits("11XLIEFERANT2--E"), ConditionResult::False);
        let arbeit = w("9991000003246");
        assert_eq!(arbeit.fits("1.125"), ConditionResult::True);
        assert_eq!(arbeit.fits("1.1255"), ConditionResult::False);
        assert_eq!(arbeit.fits("-0.5"), ConditionResult::False);
    }

    #[test]
    fn anmeldung_products_name_their_pids() {
        let table = AbrechnungsdatenProdukte::anmeldung();
        assert_eq!(table.products(Edition::V1_3c).len(), 18);
        assert_eq!(table.products(Edition::V1_4).len(), 26);
        let bilanzkreis = table
            .product(Edition::V1_3c, "9991000002082")
            .expect("Bilanzkreis");
        assert_eq!(bilanzkreis.chapter.as_deref(), Some("6.1.1"));
        assert!(bilanzkreis.property_codes.is_empty());
        assert!(bilanzkreis.orderable_by("55014"));
        // 55014 may order the Bilanzkreis and nothing else.
        let for_55014: Vec<&str> = table
            .products(Edition::V1_3c)
            .iter()
            .filter(|p| p.orderable_by("55014"))
            .map(|p| p.code.as_str())
            .collect();
        assert_eq!(for_55014, ["9991000002082"]);
        let w = bilanzkreis.wertedetails.as_ref().expect("a Wertedetail");
        assert_eq!(w.example_value(None), Some(EXAMPLE_BILANZKREIS));
        let verbrauchsart = table
            .product(Edition::V1_3c, "9991000002727")
            .expect("Verbrauchsart");
        assert_eq!(verbrauchsart.max_repetitions, Some(5));
        assert!(verbrauchsart.wertedetails.is_none());
    }

    #[test]
    fn tranchengroesse_takes_its_value_beside_its_property() {
        let table = AbrechnungsdatenProdukte::anmeldung();
        let w = |edition| {
            table
                .product(edition, "9991000002090")
                .and_then(|p| p.wertedetails.as_ref())
                .expect("Tranchengröße")
        };
        let share = Some("9991000003014");
        let factor = Some("9991000003022");
        let tr = Some("9991000003220");
        let old = w(Edition::V1_3c);
        assert!(old.needed_beside(share));
        assert!(!old.needed_beside(factor));
        assert_eq!(old.fits_beside("50.25", share), ConditionResult::True);
        assert_eq!(old.fits_beside("100", share), ConditionResult::False);
        assert_eq!(old.fits_beside("0", share), ConditionResult::False);
        assert_eq!(old.fits_beside("50.125", share), ConditionResult::False);
        assert_eq!(old.example_value(share), Some("50"));
        let new = w(Edition::V1_4);
        assert!(new.needed_beside(tr));
        assert_eq!(new.example_value(tr), Some("D1234567890"));
        assert_eq!(new.fits_beside("50", tr), ConditionResult::False);
        assert_eq!(new.fits_beside("D1234567890", None), ConditionResult::True);
    }

    #[test]
    fn example_bilanzkreis_is_a_valid_eic() {
        assert!(is_eic(EXAMPLE_BILANZKREIS));
        assert!(is_eic("11XLIEFERANT2--E"));
        assert!(is_eic("10YDE-RWENET---I"));
        assert!(!is_eic("10YDE-RWENET---J"));
        assert!(!is_eic("DKWP98GBANI7"));
    }
}