j-law-ruby 0.0.3

data/vendor/rust/crates/j-law-core/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "j-law-core"
+version = "0.0.3"
+edition = "2021"
+rust-version = "1.94"
+license = "MIT"
+publish = false
+
+[lints]
+workspace = true
+
+[dependencies]
+thiserror = "1"
+
+[dev-dependencies]
+j-law-registry = { path = "../j-law-registry" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

data/vendor/rust/crates/j-law-core/src/domains/consumption_tax/calculator.rs

@@ -0,0 +1,216 @@
+use std::collections::HashSet;
+
+use crate::domains::consumption_tax::context::{ConsumptionTaxContext, ConsumptionTaxFlag};
+use crate::domains::consumption_tax::params::ConsumptionTaxParams;
+use crate::error::{CalculationError, JLawError};
+use crate::types::amount::{FinalAmount, IntermediateAmount};
+use crate::types::rate::{MultiplyOrder, Rate};
+
+/// 消費税の計算結果。
+#[derive(Debug, Clone)]
+pub struct ConsumptionTaxResult {
+    /// 消費税額（切り捨て後）。
+    pub tax_amount: FinalAmount,
+    /// 税込み金額（課税標準額 + 消費税額）。
+    pub amount_with_tax: FinalAmount,
+    /// 課税標準額（税抜き）。`ctx.amount` と等しい。
+    pub amount_without_tax: FinalAmount,
+    /// 適用した税率の分子。
+    pub applied_rate_numer: u64,
+    /// 適用した税率の分母。
+    pub applied_rate_denom: u64,
+    /// 軽減税率が適用されたか。
+    pub is_reduced_rate: bool,
+    /// 適用されたフラグ。
+    pub applied_flags: HashSet<ConsumptionTaxFlag>,
+}
+
+/// 消費税法第29条に基づく消費税を計算する。
+///
+/// # 法的根拠
+/// 消費税法 第29条（税率）
+/// 消費税法 第45条（端数処理: 1円未満切り捨て）
+///
+/// # 計算手順
+/// 1. ポリシーで軽減税率を適用するか判定する
+/// 2. 軽減税率適用フラグがあっても `reduced_rate` が `None` の場合は
+///    [`CalculationError::PolicyNotApplicable`] を返す
+/// 3. 課税標準額 × 税率（切り捨て）で消費税額を算出する
+/// 4. 課税標準額 + 消費税額で税込み金額を算出する
+///
+/// # 税率が0の場合（消費税導入前）
+/// `standard_rate.numer == 0` のとき、税額は0として計算結果を返す。
+pub fn calculate_consumption_tax(
+    ctx: &ConsumptionTaxContext,
+    params: &ConsumptionTaxParams,
+) -> Result<ConsumptionTaxResult, JLawError> {
+    ctx.target_date.validate()?;
+
+    let amount = ctx.amount;
+    let rounding = ctx.policy.tax_rounding();
+    let use_reduced = ctx.policy.should_apply_reduced_rate(&ctx.flags);
+
+    let (applied_rate, is_reduced) = if use_reduced {
+        let reduced = params.reduced_rate.ok_or_else(|| CalculationError::PolicyNotApplicable {
+            reason: format!(
+                "軽減税率フラグが指定されましたが、対象日({})の消費税パラメータに軽減税率が存在しません",
+                ctx.target_date.to_date_str()
+            ),
+        })?;
+        (reduced, true)
+    } else {
+        (params.standard_rate, false)
+    };
+
+    // 税率が0の場合（消費税導入前）は税額0を返す
+    let tax_amount = if applied_rate.numer == 0 {
+        FinalAmount::new(0)
+    } else {
+        let rate = Rate::new(applied_rate.numer, applied_rate.denom).map_err(|_| {
+            CalculationError::Overflow {
+                step: "consumption_tax_rate".into(),
+            }
+        })?;
+        // Rate::apply() は端数処理済みの整数を from_exact で包んで返す（numer=0）。
+        // そのため .finalize() では端数部が0として評価され、二重端数処理は発生しない。
+        rate.apply(
+            &IntermediateAmount::from_exact(amount),
+            MultiplyOrder::MultiplyFirst,
+            rounding,
+        )?
+        .finalize(rounding)?
+    };
+
+    let amount_with_tax =
+        FinalAmount::new(amount.checked_add(tax_amount.as_yen()).ok_or_else(|| {
+            CalculationError::Overflow {
+                step: "consumption_tax".into(),
+            }
+        })?);
+
+    Ok(ConsumptionTaxResult {
+        tax_amount,
+        amount_with_tax,
+        amount_without_tax: FinalAmount::new(amount),
+        applied_rate_numer: applied_rate.numer,
+        applied_rate_denom: applied_rate.denom,
+        is_reduced_rate: is_reduced,
+        applied_flags: ctx.flags.clone(),
+    })
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+    use crate::domains::consumption_tax::params::ConsumptionTaxRate;
+    use crate::domains::consumption_tax::policy::StandardConsumptionTaxPolicy;
+    use crate::LegalDate;
+
+    fn params_10pct() -> ConsumptionTaxParams {
+        ConsumptionTaxParams {
+            standard_rate: ConsumptionTaxRate {
+                numer: 10,
+                denom: 100,
+            },
+            reduced_rate: Some(ConsumptionTaxRate {
+                numer: 8,
+                denom: 100,
+            }),
+        }
+    }
+
+    fn ctx_standard(amount: u64) -> ConsumptionTaxContext {
+        ConsumptionTaxContext {
+            amount,
+            target_date: LegalDate::new(2020, 1, 1),
+            flags: HashSet::new(),
+            policy: Box::new(StandardConsumptionTaxPolicy),
+        }
+    }
+
+    fn ctx_reduced(amount: u64) -> ConsumptionTaxContext {
+        let mut flags = HashSet::new();
+        flags.insert(ConsumptionTaxFlag::ReducedRate);
+        ConsumptionTaxContext {
+            amount,
+            target_date: LegalDate::new(2020, 1, 1),
+            flags,
+            policy: Box::new(StandardConsumptionTaxPolicy),
+        }
+    }
+
+    #[test]
+    fn standard_10pct() {
+        let result = calculate_consumption_tax(&ctx_standard(100_000), &params_10pct()).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 10_000);
+        assert_eq!(result.amount_with_tax.as_yen(), 110_000);
+        assert_eq!(result.amount_without_tax.as_yen(), 100_000);
+        assert!(!result.is_reduced_rate);
+    }
+
+    #[test]
+    fn reduced_8pct() {
+        let result = calculate_consumption_tax(&ctx_reduced(100_000), &params_10pct()).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 8_000);
+        assert_eq!(result.amount_with_tax.as_yen(), 108_000);
+        assert!(result.is_reduced_rate);
+    }
+
+    #[test]
+    fn floor_rounding() {
+        // 100,001 × 10% = 10,000.1 → 切り捨て → 10,000
+        let result = calculate_consumption_tax(&ctx_standard(100_001), &params_10pct()).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 10_000);
+    }
+
+    #[test]
+    fn zero_amount() {
+        let result = calculate_consumption_tax(&ctx_standard(0), &params_10pct()).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 0);
+        assert_eq!(result.amount_with_tax.as_yen(), 0);
+    }
+
+    #[test]
+    fn zero_rate_no_tax() {
+        let params = ConsumptionTaxParams {
+            standard_rate: ConsumptionTaxRate {
+                numer: 0,
+                denom: 100,
+            },
+            reduced_rate: None,
+        };
+        let result = calculate_consumption_tax(&ctx_standard(100_000), &params).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 0);
+        assert_eq!(result.amount_with_tax.as_yen(), 100_000);
+    }
+
+    #[test]
+    fn reduced_flag_without_reduced_rate_is_error() {
+        let params = ConsumptionTaxParams {
+            standard_rate: ConsumptionTaxRate {
+                numer: 8,
+                denom: 100,
+            },
+            reduced_rate: None, // 軽減税率なし
+        };
+        let result = calculate_consumption_tax(&ctx_reduced(100_000), &params);
+        assert!(matches!(
+            result,
+            Err(JLawError::Calculation(
+                crate::error::CalculationError::PolicyNotApplicable { .. }
+            ))
+        ));
+    }
+
+    #[test]
+    fn invalid_target_date_is_rejected() {
+        let mut ctx = ctx_standard(100_000);
+        ctx.target_date = LegalDate::new(2024, 2, 30);
+        let result = calculate_consumption_tax(&ctx, &params_10pct());
+        assert!(matches!(
+            result,
+            Err(JLawError::Input(crate::InputError::InvalidDate { .. }))
+        ));
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/consumption_tax/context.rs

@@ -0,0 +1,29 @@
+use std::collections::HashSet;
+
+use crate::domains::consumption_tax::policy::ConsumptionTaxPolicy;
+use crate::types::date::LegalDate;
+
+/// 消費税計算に影響するフラグ。
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ConsumptionTaxFlag {
+    /// 軽減税率（8%）を適用する。
+    ///
+    /// # WARNING
+    /// 「軽減税率の対象品目に該当するか」の事実認定はライブラリの責任範囲外。
+    /// 呼び出し元が適切に判断してこのフラグを設定すること。
+    /// 対象品目: 飲食料品（酒類・外食を除く）、定期購読の新聞（2019年10月1日〜）。
+    ReducedRate,
+}
+
+/// 消費税計算のコンテキスト。
+#[derive(Debug)]
+pub struct ConsumptionTaxContext {
+    /// 課税標準額（税抜き金額・円）。
+    pub amount: u64,
+    /// 計算対象日。
+    pub target_date: LegalDate,
+    /// 適用フラグ。
+    pub flags: HashSet<ConsumptionTaxFlag>,
+    /// 端数処理・特例判定ポリシー。
+    pub policy: Box<dyn ConsumptionTaxPolicy>,
+}

data/vendor/rust/crates/j-law-core/src/domains/consumption_tax/mod.rs

@@ -0,0 +1,9 @@
+pub mod calculator;
+pub mod context;
+pub mod params;
+pub mod policy;
+
+pub use calculator::{calculate_consumption_tax, ConsumptionTaxResult};
+pub use context::{ConsumptionTaxContext, ConsumptionTaxFlag};
+pub use params::{ConsumptionTaxParams, ConsumptionTaxRate};
+pub use policy::StandardConsumptionTaxPolicy;

data/vendor/rust/crates/j-law-core/src/domains/consumption_tax/params.rs

@@ -0,0 +1,24 @@
+/// 消費税率（分子・分母表現）。
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ConsumptionTaxRate {
+    pub numer: u64,
+    pub denom: u64,
+}
+
+/// 消費税計算パラメータ。
+///
+/// # 法的根拠
+/// 消費税法 第29条
+///
+/// # 税率の歴史
+/// - 3%: 1989年4月1日〜1997年3月31日
+/// - 5%: 1997年4月1日〜2014年3月31日
+/// - 8%: 2014年4月1日〜2019年9月30日
+/// - 10%（標準）/ 8%（軽減）: 2019年10月1日〜
+#[derive(Debug, Clone)]
+pub struct ConsumptionTaxParams {
+    /// 標準税率。
+    pub standard_rate: ConsumptionTaxRate,
+    /// 軽減税率。2019年10月1日以降の飲食料品・新聞等に適用。それ以前は `None`。
+    pub reduced_rate: Option<ConsumptionTaxRate>,
+}

data/vendor/rust/crates/j-law-core/src/domains/consumption_tax/policy.rs

@@ -0,0 +1,34 @@
+use std::collections::HashSet;
+
+use crate::domains::consumption_tax::context::ConsumptionTaxFlag;
+use crate::types::rounding::RoundingStrategy;
+
+/// 消費税計算のポリシーインターフェース。
+///
+/// 端数処理戦略や軽減税率の適用判定ロジックを差し替えられるようにする。
+/// 通常は [`StandardConsumptionTaxPolicy`] を使う。
+pub trait ConsumptionTaxPolicy: std::fmt::Debug {
+    /// 軽減税率をフラグに基づいて適用するかどうかを判定する。
+    fn should_apply_reduced_rate(&self, flags: &HashSet<ConsumptionTaxFlag>) -> bool;
+
+    /// 税額計算に使う端数処理戦略。
+    fn tax_rounding(&self) -> RoundingStrategy;
+}
+
+/// 消費税法の標準解釈に基づく消費税計算ポリシー。
+///
+/// # 法的根拠
+/// 消費税法 第29条
+/// 消費税法 第45条（端数処理: 1円未満切り捨て）
+#[derive(Debug, Clone, Copy)]
+pub struct StandardConsumptionTaxPolicy;
+
+impl ConsumptionTaxPolicy for StandardConsumptionTaxPolicy {
+    fn should_apply_reduced_rate(&self, flags: &HashSet<ConsumptionTaxFlag>) -> bool {
+        flags.contains(&ConsumptionTaxFlag::ReducedRate)
+    }
+
+    fn tax_rounding(&self) -> RoundingStrategy {
+        RoundingStrategy::Floor
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/income_tax/assessment.rs

@@ -0,0 +1,76 @@
+use std::collections::HashSet;
+use std::fmt;
+
+use crate::domains::income_tax::calculator::{calculate_income_tax_inner, IncomeTaxResult};
+use crate::domains::income_tax::context::IncomeTaxFlag;
+use crate::domains::income_tax::deduction::{
+    calculate_income_deductions, IncomeDeductionContext, IncomeDeductionParams,
+    IncomeDeductionResult,
+};
+use crate::domains::income_tax::params::IncomeTaxParams;
+use crate::domains::income_tax::policy::IncomeTaxPolicy;
+use crate::error::JLawError;
+
+/// 所得控除の計算から所得税額の算出までを通しで実行するコンテキスト。
+///
+/// # 法的根拠
+/// 所得税法 第74条（社会保険料控除）
+/// 所得税法 第86条（基礎控除）
+/// 所得税法 第89条第1項（所得税の税率）
+pub struct IncomeTaxAssessmentContext {
+    /// 所得控除の入力コンテキスト。
+    pub deduction_context: IncomeDeductionContext,
+    /// 適用する法的フラグの集合。
+    pub flags: HashSet<IncomeTaxFlag>,
+    /// 計算ポリシー。
+    pub policy: Box<dyn IncomeTaxPolicy>,
+}
+
+impl fmt::Debug for IncomeTaxAssessmentContext {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("IncomeTaxAssessmentContext")
+            .field("deduction_context", &self.deduction_context)
+            .field("flags", &self.flags)
+            .field("policy", &"<policy>")
+            .finish()
+    }
+}
+
+/// 所得控除と所得税額の通し計算結果。
+///
+/// # 法的根拠
+/// 所得税法 第74条（社会保険料控除）
+/// 所得税法 第86条（基礎控除）
+/// 所得税法 第89条第1項（所得税の税率）
+/// 復興財源確保法 第13条（復興特別所得税）
+#[derive(Debug, Clone)]
+pub struct IncomeTaxAssessmentResult {
+    /// 所得控除の計算結果。
+    pub deductions: IncomeDeductionResult,
+    /// 課税所得金額に対する所得税額の計算結果。
+    pub tax: IncomeTaxResult,
+}
+
+/// 所得控除の計算結果を使って所得税額を算出する。
+///
+/// # 法的根拠
+/// 所得税法 第74条（社会保険料控除）
+/// 所得税法 第86条（基礎控除）
+/// 所得税法 第89条第1項（所得税の税率）
+/// 復興財源確保法 第13条（復興特別所得税）
+pub fn calculate_income_tax_assessment(
+    ctx: &IncomeTaxAssessmentContext,
+    deduction_params: &IncomeDeductionParams,
+    tax_params: &IncomeTaxParams,
+) -> Result<IncomeTaxAssessmentResult, JLawError> {
+    let deductions = calculate_income_deductions(&ctx.deduction_context, deduction_params)?;
+    let tax = calculate_income_tax_inner(
+        deductions.taxable_income.as_yen(),
+        ctx.deduction_context.target_date,
+        &ctx.flags,
+        ctx.policy.as_ref(),
+        tax_params,
+    )?;
+
+    Ok(IncomeTaxAssessmentResult { deductions, tax })
+}

data/vendor/rust/crates/j-law-core/src/domains/income_tax/calculator.rs

@@ -0,0 +1,222 @@
+use std::collections::HashSet;
+
+use crate::domains::income_tax::context::{IncomeTaxContext, IncomeTaxFlag};
+use crate::domains::income_tax::params::IncomeTaxParams;
+use crate::domains::income_tax::policy::IncomeTaxPolicy;
+use crate::error::{CalculationError, JLawError};
+use crate::types::amount::{FinalAmount, IntermediateAmount};
+use crate::types::date::LegalDate;
+use crate::types::rate::{MultiplyOrder, Rate};
+
+/// 所得税の計算ステップ（内訳明細用）。
+///
+/// 速算表の適用結果を記録する。
+#[derive(Debug, Clone)]
+pub struct IncomeTaxStep {
+    /// ブラケットの表示名（例: "330万円超695万円以下"）。
+    pub label: String,
+    /// 課税所得金額（円）。
+    pub taxable_income: u64,
+    /// 適用された税率の分子。
+    pub rate_numer: u64,
+    /// 適用された税率の分母。
+    pub rate_denom: u64,
+    /// 速算表の控除額（円）。
+    pub deduction: u64,
+    /// このステップでの算出税額（課税所得 × 税率 - 控除額）。
+    pub result: FinalAmount,
+}
+
+/// 所得税の計算結果。
+///
+/// # 法的根拠
+/// 所得税法 第89条第1項（所得税の税率）
+/// 復興財源確保法 第13条（復興特別所得税）
+/// 国税通則法 第119条第1項（税額の端数処理）
+#[derive(Debug, Clone)]
+pub struct IncomeTaxResult {
+    /// 基準所得税額（復興特別所得税を含まない）。
+    pub base_tax: FinalAmount,
+    /// 復興特別所得税額（適用されない場合は0円）。
+    pub reconstruction_tax: FinalAmount,
+    /// 申告納税額（基準所得税額 + 復興特別所得税額）。
+    ///
+    /// 100円未満切り捨て（国税通則法 第119条第1項）。
+    pub total_tax: FinalAmount,
+    /// 計算の内訳ステップ。
+    pub breakdown: Vec<IncomeTaxStep>,
+    /// 適用されたフラグ。
+    pub applied_flags: HashSet<IncomeTaxFlag>,
+    /// 復興特別所得税が適用されたか。
+    pub reconstruction_tax_applied: bool,
+}
+
+/// 所得税法第89条に基づく所得税額を計算する。
+///
+/// # 法的根拠
+/// 所得税法 第89条第1項（税率表・速算表方式）
+/// 復興財源確保法 第13条（復興特別所得税 2.1%）
+/// 国税通則法 第119条第1項（申告納税額の100円未満切り捨て）
+///
+/// # 計算手順
+/// 1. 課税所得金額が該当するブラケットを特定する
+/// 2. 速算表方式で基準所得税額を算出: 課税所得金額 × 税率 - 控除額
+/// 3. 復興特別所得税が適用される場合: 基準所得税額 × 21/1000（1円未満切り捨て）
+/// 4. 申告納税額 = 基準所得税額 + 復興特別所得税額（100円未満切り捨て）
+pub fn calculate_income_tax(
+    ctx: &IncomeTaxContext,
+    params: &IncomeTaxParams,
+) -> Result<IncomeTaxResult, JLawError> {
+    calculate_income_tax_inner(
+        ctx.taxable_income,
+        ctx.target_date,
+        &ctx.flags,
+        ctx.policy.as_ref(),
+        params,
+    )
+}
+
+pub(crate) fn calculate_income_tax_inner(
+    taxable_income: u64,
+    target_date: LegalDate,
+    flags: &HashSet<IncomeTaxFlag>,
+    policy: &dyn IncomeTaxPolicy,
+    params: &IncomeTaxParams,
+) -> Result<IncomeTaxResult, JLawError> {
+    target_date.validate()?;
+
+    let income = taxable_income;
+    let tax_rounding = policy.tax_rounding();
+
+    // --- 課税所得金額が0の場合 ---
+    if income == 0 {
+        return Ok(IncomeTaxResult {
+            base_tax: FinalAmount::new(0),
+            reconstruction_tax: FinalAmount::new(0),
+            total_tax: FinalAmount::new(0),
+            breakdown: vec![],
+            applied_flags: flags.clone(),
+            reconstruction_tax_applied: false,
+        });
+    }
+
+    // --- 該当ブラケットの特定 ---
+    let bracket = params
+        .brackets
+        .iter()
+        .find(|b| {
+            income >= b.income_from
+                && match b.income_to_inclusive {
+                    Some(to) => income <= to,
+                    None => true,
+                }
+        })
+        .ok_or_else(|| CalculationError::PolicyNotApplicable {
+            reason: format!(
+                "課税所得金額 {}円 に対応する税率ブラケットが見つかりません",
+                income
+            ),
+        })?;
+
+    // --- 速算表方式による基準所得税額の計算 ---
+    // 税額 = 課税所得金額 × 税率 - 控除額
+    let rate = Rate::new(bracket.rate_numer, bracket.rate_denom).map_err(|_| {
+        CalculationError::Overflow {
+            step: "income_tax_rate".into(),
+        }
+    })?;
+    let gross_tax = rate
+        .apply(
+            &IntermediateAmount::from_exact(income),
+            MultiplyOrder::MultiplyFirst,
+            tax_rounding,
+        )?
+        .finalize(tax_rounding)?;
+
+    let base_tax_yen = gross_tax
+        .as_yen()
+        .checked_sub(bracket.deduction)
+        .ok_or_else(|| CalculationError::Overflow {
+            step: "base_tax_deduction".into(),
+        })?;
+
+    let base_tax = FinalAmount::new(base_tax_yen);
+
+    let breakdown = vec![IncomeTaxStep {
+        label: bracket.label.clone(),
+        taxable_income: income,
+        rate_numer: bracket.rate_numer,
+        rate_denom: bracket.rate_denom,
+        deduction: bracket.deduction,
+        result: base_tax,
+    }];
+
+    // --- 復興特別所得税 ---
+    let target_year = target_date.year;
+    let apply_reconstruction = policy.should_apply_reconstruction_tax(target_year, flags);
+
+    let reconstruction_tax_yen = if apply_reconstruction {
+        if let Some(rt_params) = &params.reconstruction_tax {
+            let rt_rate = Rate::new(rt_params.rate_numer, rt_params.rate_denom).map_err(|_| {
+                CalculationError::Overflow {
+                    step: "reconstruction_tax_rate".into(),
+                }
+            })?;
+            let rt_rounding = policy.reconstruction_tax_rounding();
+            rt_rate
+                .apply(
+                    &IntermediateAmount::from_exact(base_tax_yen),
+                    MultiplyOrder::MultiplyFirst,
+                    rt_rounding,
+                )?
+                .finalize(rt_rounding)?
+                .as_yen()
+        } else {
+            return Err(CalculationError::PolicyNotApplicable {
+                reason: "ApplyReconstructionTaxフラグが指定されましたが、パラメータセットに復興特別所得税データが含まれていません".into(),
+            }
+            .into());
+        }
+    } else {
+        0
+    };
+
+    let reconstruction_tax = FinalAmount::new(reconstruction_tax_yen);
+
+    // --- 申告納税額（100円未満切り捨て） ---
+    // 国税通則法 第119条第1項
+    let total_before_truncation = base_tax_yen
+        .checked_add(reconstruction_tax_yen)
+        .ok_or_else(|| CalculationError::Overflow {
+            step: "total_tax".into(),
+        })?;
+    let total_tax = FinalAmount::new(truncate_below_100(total_before_truncation));
+
+    Ok(IncomeTaxResult {
+        base_tax,
+        reconstruction_tax,
+        total_tax,
+        breakdown,
+        applied_flags: flags.clone(),
+        reconstruction_tax_applied: apply_reconstruction,
+    })
+}
+
+/// 100円未満を切り捨てる（国税通則法 第119条第1項）。
+fn truncate_below_100(amount: u64) -> u64 {
+    amount / 100 * 100
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn truncate_below_100_works() {
+        assert_eq!(truncate_below_100(0), 0);
+        assert_eq!(truncate_below_100(99), 0);
+        assert_eq!(truncate_below_100(100), 100);
+        assert_eq!(truncate_below_100(199), 100);
+        assert_eq!(truncate_below_100(584_522), 584_500);
+    }
+}