@novha/calc-engines 6.3.0 → 7.0.1

package/test/india-income-tax.test.ts

@@ -0,0 +1,78 @@
+import { IndiaIncomeTaxServiceImpl } from '../src/income-tax/india/IndiaIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/india/domain/types';
+
+const indiaRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 300000, rate: 0 },
+        { from: 300000, to: 700000, rate: 0.05 },
+        { from: 700000, to: 1000000, rate: 0.10 },
+        { from: 1000000, to: 1200000, rate: 0.15 },
+        { from: 1200000, to: 1500000, rate: 0.20 },
+        { from: 1500000, to: null, rate: 0.30 },
+    ],
+    cess: { rate: 0.04 },
+};
+
+describe('IndiaIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new IndiaIncomeTaxServiceImpl(0, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.cess).toBe(0);
+        expect(result.totalDeductions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('returns zero income tax for income below the basic exemption (300000)', () => {
+        const service = new IndiaIncomeTaxServiceImpl(200000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.cess).toBe(0);
+        expect(result.grossIncome).toBe(200000);
+    });
+
+    it('correctly calculates tax and cess for income spanning multiple brackets', () => {
+        const service = new IndiaIncomeTaxServiceImpl(800000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        // 0-300000: 0 tax
+        // 300000-700000: 400000 * 0.05 = 20000
+        // 700000-800000: 100000 * 0.10 = 10000
+        // grossTax = 30000
+        // cess = 30000 * 0.04 = 1200
+        expect(result.incomeTax).toBeCloseTo(30000, 2);
+        expect(result.cess).toBeCloseTo(1200, 2);
+    });
+
+    it('correctly calculates total deductions as income tax plus cess', () => {
+        const service = new IndiaIncomeTaxServiceImpl(800000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.totalDeductions).toBeCloseTo(result.incomeTax + result.cess, 2);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new IndiaIncomeTaxServiceImpl(800000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('calculates effective tax rate as income tax divided by gross income', () => {
+        const service = new IndiaIncomeTaxServiceImpl(1000000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(result.incomeTax / result.grossIncome, 4);
+    });
+
+    it('correctly applies the top bracket for high income', () => {
+        const service = new IndiaIncomeTaxServiceImpl(2000000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBeGreaterThan(0);
+        const lastBreakdown = result.taxBracketBreakdown[result.taxBracketBreakdown.length - 1];
+        expect(lastBreakdown.rate).toBe(0.30);
+    });
+});

package/test/india-mortgage.test.ts

@@ -0,0 +1,70 @@
+import { IndiaMortgageServiceImpl } from '../src/mortgage/india/IndiaMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/india/domain/types';
+
+const indiaRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.75, maxAmortizationYears: 30 },
+    interest: { compounding: 'MONTHLY' },
+    stampDuty: { rate: 0.05 },
+};
+
+const input: MortgageInput = {
+    propertyPrice: 10000000,
+    downPayment: 2000000,
+    annualInterestRate: 8.5,
+    amortizationYears: 20,
+    isFirstTimeBuyer: false,
+};
+
+describe('IndiaMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        // loanAmount = 10000000 - 2000000 = 8000000
+        expect(result.loanAmount).toBe(8000000);
+    });
+
+    it('correctly calculates stamp duty', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        // stampDuty = 10000000 * 0.05 = 500000
+        expect(result.stampDuty).toBe(500000);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        expect(result.amortizationSchedule).toHaveLength(20);
+    });
+
+    it('total paid equals monthly payment multiplied by total payments', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        const expectedTotal = result.monthlyPayment * (input.amortizationYears * 12);
+        expect(result.totalPaid).toBeCloseTo(expectedTotal, 2);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 10000000 };
+
+        expect(() => service.calculate(badInput, indiaRules)).toThrow();
+    });
+});

package/test/israel-capital-gains.test.ts

@@ -0,0 +1,45 @@
+import { IsraelCapitalGainsServiceImpl } from '../src/capital-gains/israel/IsraelCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/israel/domain/types';
+
+const israelRules: Rules = {
+    brackets: [
+        { from: 0, to: null, rate: 0.25 },
+    ],
+};
+
+describe('IsraelCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.taxableGain).toBe(0);
+        expect(result.capitalGainTax).toBe(0);
+        expect(result.totalTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly calculates flat 25% tax', () => {
+        const input: Input = { capitalGain: 100000 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        const result = service.calculate();
+        // 100000 * 0.25 = 25000
+        expect(result.capitalGainTax).toBe(25000);
+        expect(result.totalTax).toBe(25000);
+        expect(result.effectiveRate).toBe(25);
+    });
+
+    it('taxable gain equals input capital gain', () => {
+        const input: Input = { capitalGain: 50000 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.taxableGain).toBe(50000);
+    });
+
+    it('effective rate equals total tax divided by gain times 100', () => {
+        const input: Input = { capitalGain: 200000 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.effectiveRate).toBeCloseTo((result.capitalGainTax / 200000) * 100, 2);
+    });
+});

package/test/israel-corporate-tax.test.ts

@@ -0,0 +1,49 @@
+import { IsraelCorporateTaxServiceImpl } from '../src/corporate/israel/IsraelCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/israel/domain/types';
+
+const israelRules: Rules = {
+    regime: { type: 'flat', rate: 0.23 },
+};
+
+describe('IsraelCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new IsraelCorporateTaxServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly applies the flat 23% rate', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new IsraelCorporateTaxServiceImpl(input, israelRules);
+        const result = service.calculate();
+        // 100000 * 0.23 = 23000
+        expect(result.corporateTax).toBe(23000);
+    });
+
+    it('calculates effective tax rate as percentage', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new IsraelCorporateTaxServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.effectiveTaxRate).toBe(23);
+    });
+
+    it('returns one breakdown entry for flat rate calculation', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new IsraelCorporateTaxServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.23);
+        expect(result.breakdowns[0].amount).toBe(23000);
+    });
+
+    it('scales linearly with taxable income', () => {
+        const input: Input = { taxableIncome: 500000 };
+        const service = new IsraelCorporateTaxServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.corporateTax).toBe(115000);
+        expect(result.effectiveTaxRate).toBe(23);
+    });
+});

package/test/israel-income-tax.test.ts

@@ -0,0 +1,76 @@
+import { IsraelIncomeTaxServiceImpl } from '../src/income-tax/israel/IsraelIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/israel/domain/types';
+
+const israelRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 81480, rate: 0.10 },
+        { from: 81480, to: 116760, rate: 0.14 },
+        { from: 116760, to: 187440, rate: 0.20 },
+        { from: 187440, to: 260520, rate: 0.31 },
+        { from: 260520, to: 542160, rate: 0.35 },
+        { from: 542160, to: null, rate: 0.47 },
+    ],
+    socialContributions: { rate: 0.12 },
+};
+
+describe('IsraelIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new IsraelIncomeTaxServiceImpl(0, israelRules);
+        const result = service.calculateNetIncome();
+        expect(result.incomeTax).toBe(0);
+        expect(result.socialContributions).toBe(0);
+        expect(result.totalDeductions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('correctly calculates income tax for income in first bracket', () => {
+        const service = new IsraelIncomeTaxServiceImpl(50000, israelRules);
+        const result = service.calculateNetIncome();
+        // 50000 * 0.10 = 5000
+        expect(result.incomeTax).toBeCloseTo(5000, 2);
+        expect(result.grossIncome).toBe(50000);
+    });
+
+    it('correctly calculates social contributions', () => {
+        const service = new IsraelIncomeTaxServiceImpl(50000, israelRules);
+        const result = service.calculateNetIncome();
+        // 50000 * 0.12 = 6000
+        expect(result.socialContributions).toBeCloseTo(6000, 2);
+    });
+
+    it('correctly calculates income tax spanning multiple brackets', () => {
+        const service = new IsraelIncomeTaxServiceImpl(120000, israelRules);
+        const result = service.calculateNetIncome();
+        // 0-81480: 81480 * 0.10 = 8148
+        // 81480-116760: 35280 * 0.14 = 4939.2
+        // 116760-120000: 3240 * 0.20 = 648
+        // Total = 13735.2
+        expect(result.incomeTax).toBeCloseTo(13735.2, 1);
+    });
+
+    it('calculates effective tax rate as income tax divided by gross income', () => {
+        const service = new IsraelIncomeTaxServiceImpl(120000, israelRules);
+        const result = service.calculateNetIncome();
+        expect(result.effectiveTaxRate).toBeCloseTo(result.incomeTax / result.grossIncome, 4);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new IsraelIncomeTaxServiceImpl(120000, israelRules);
+        const result = service.calculateNetIncome();
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('total deductions equals income tax plus social contributions', () => {
+        const service = new IsraelIncomeTaxServiceImpl(120000, israelRules);
+        const result = service.calculateNetIncome();
+        expect(result.totalDeductions).toBeCloseTo(result.incomeTax + result.socialContributions, 2);
+    });
+
+    it('applies highest bracket rate to income above 542160', () => {
+        const service = new IsraelIncomeTaxServiceImpl(600000, israelRules);
+        const result = service.calculateNetIncome();
+        expect(result.incomeTax).toBeGreaterThan(0);
+        const lastBreakdown = result.taxBracketBreakdown[result.taxBracketBreakdown.length - 1];
+        expect(lastBreakdown.rate).toBe(0.47);
+    });
+});

package/test/israel-mortgage.test.ts

@@ -0,0 +1,80 @@
+import { IsraelMortgageServiceImpl } from '../src/mortgage/israel/IsraelMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/israel/domain/types';
+
+const israelRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.75, maxAmortizationYears: 30 },
+    interest: { compounding: 'MONTHLY' },
+    purchaseTax: {
+        brackets: [
+            { upTo: 1978745, rate: 0 },
+            { upTo: 5872725, rate: 0.035 },
+            { upTo: 16140600, rate: 0.05 },
+            { upTo: 21520800, rate: 0.08 },
+            { above: 21520800, rate: 0.10 },
+        ],
+    },
+    landRegistrationFeeRate: 0.0025,
+};
+
+const input: MortgageInput = {
+    propertyPrice: 2000000,
+    downPayment: 500000,
+    annualInterestRate: 4.5,
+    amortizationYears: 25,
+    isFirstTimeBuyer: true,
+};
+
+describe('IsraelMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.loanAmount).toBe(1500000);
+    });
+
+    it('correctly calculates purchase tax for first-time buyer', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        // 0-1978745: 0% tax = 0
+        // 1978745-2000000: 21255 * 0.035 = 743.925
+        expect(result.purchaseTax).toBeCloseTo(743.93, 1);
+    });
+
+    it('correctly calculates land registration fee', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        // 2000000 * 0.0025 = 5000
+        expect(result.landRegistrationFee).toBeCloseTo(5000, 2);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.amortizationSchedule).toHaveLength(25);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 2000000 };
+        expect(() => service.calculate(badInput, israelRules)).toThrow();
+    });
+
+    it('non-first-time buyer pays flat 8% purchase tax', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const nonFtbInput: MortgageInput = { ...input, isFirstTimeBuyer: false };
+        const result = service.calculate(nonFtbInput, israelRules);
+        // 2000000 * 0.08 = 160000
+        expect(result.purchaseTax).toBeCloseTo(160000, 2);
+    });
+});

package/test/japan-capital-gains.test.ts

@@ -0,0 +1,55 @@
+import { JapanCapitalGainsServiceImpl } from '../src/capital-gains/japan/JapanCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/japan/domain/types';
+
+const japanRules: Rules = {
+    flatRate: 0.20315,
+};
+
+describe('JapanCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(0);
+        expect(result.capitalGainTax).toBe(0);
+        expect(result.totalTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly applies the flat 20.315% rate', () => {
+        const input: Input = { capitalGain: 1000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        // 1000000 * 0.20315 = 203150
+        expect(result.capitalGainTax).toBeCloseTo(203150, 2);
+        expect(result.totalTax).toBeCloseTo(203150, 2);
+    });
+
+    it('effective rate equals the flat rate as a percentage', () => {
+        const input: Input = { capitalGain: 1000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo(20.315, 3);
+    });
+
+    it('returns one breakdown entry for flat rate calculation', () => {
+        const input: Input = { capitalGain: 1000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.20315);
+    });
+
+    it('scales linearly with capital gain', () => {
+        const input: Input = { capitalGain: 5000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.capitalGainTax).toBeCloseTo(5000000 * 0.20315, 2);
+    });
+});

package/test/japan-corporate-tax.test.ts

@@ -0,0 +1,54 @@
+import { JapanCorporateTaxServiceImpl } from '../src/corporate/japan/JapanCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/japan/domain/types';
+
+const japanRules: Rules = {
+    regime: { type: 'flat', rate: 0.335 },
+};
+
+describe('JapanCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly applies the flat 33.5% rate', () => {
+        const input: Input = { taxableIncome: 10000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        // 10000000 * 0.335 = 3350000
+        expect(result.corporateTax).toBe(3350000);
+    });
+
+    it('calculates effective tax rate as percentage', () => {
+        const input: Input = { taxableIncome: 10000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.effectiveTaxRate).toBe(33.5);
+    });
+
+    it('returns one breakdown entry for flat rate calculation', () => {
+        const input: Input = { taxableIncome: 10000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.335);
+        expect(result.breakdowns[0].amount).toBe(3350000);
+    });
+
+    it('scales linearly with taxable income', () => {
+        const input: Input = { taxableIncome: 1000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(335000);
+        expect(result.effectiveTaxRate).toBe(33.5);
+    });
+});

package/test/japan-income-tax.test.ts

@@ -0,0 +1,76 @@
+import { JapanIncomeTaxServiceImpl } from '../src/income-tax/japan/JapanIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/japan/domain/types';
+
+const japanRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 1950000, rate: 0.05 },
+        { from: 1950000, to: 3300000, rate: 0.10 },
+        { from: 3300000, to: 6950000, rate: 0.20 },
+        { from: 6950000, to: 9000000, rate: 0.23 },
+        { from: 9000000, to: 18000000, rate: 0.33 },
+        { from: 18000000, to: 40000000, rate: 0.40 },
+        { from: 40000000, to: null, rate: 0.45 },
+    ],
+    inhabitantTax: { rate: 0.10 },
+};
+
+describe('JapanIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new JapanIncomeTaxServiceImpl(0, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.nationalIncomeTax).toBe(0);
+        expect(result.inhabitantTax).toBe(0);
+        expect(result.totalDeductions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('correctly calculates national income tax for income in first bracket', () => {
+        const service = new JapanIncomeTaxServiceImpl(1000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        // 0-1000000: 1000000 * 0.05 = 50000
+        expect(result.nationalIncomeTax).toBeCloseTo(50000, 2);
+        expect(result.grossIncome).toBe(1000000);
+    });
+
+    it('correctly calculates inhabitant tax as a flat rate on gross income', () => {
+        const service = new JapanIncomeTaxServiceImpl(1000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        // inhabitantTax = 1000000 * 0.10 = 100000
+        expect(result.inhabitantTax).toBeCloseTo(100000, 2);
+    });
+
+    it('correctly calculates income spanning multiple brackets', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        // 0-1950000: 1950000 * 0.05 = 97500
+        // 1950000-3300000: 1350000 * 0.10 = 135000
+        // 3300000-5000000: 1700000 * 0.20 = 340000
+        // Total = 572500
+        expect(result.nationalIncomeTax).toBeCloseTo(572500, 2);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('total deductions equals national income tax plus inhabitant tax', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.totalDeductions).toBeCloseTo(result.nationalIncomeTax + result.inhabitantTax, 2);
+    });
+
+    it('calculates effective tax rate as national income tax divided by gross income', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(result.nationalIncomeTax / result.grossIncome, 4);
+    });
+});

package/test/japan-inheritance-tax.test.ts

@@ -0,0 +1,74 @@
+import { JapanInheritanceTaxServiceImpl } from '../src/inheritance-tax/japan/JapanInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/japan/domain/types';
+
+const japanRules: Rules = {
+    baseExemption: 30000000,
+    perHeirExemption: 6000000,
+    taxBrackets: [
+        { from: 0, to: 10000000, rate: 0.10 },
+        { from: 10000000, to: 30000000, rate: 0.15 },
+        { from: 30000000, to: 50000000, rate: 0.20 },
+        { from: 50000000, to: 100000000, rate: 0.30 },
+        { from: 100000000, to: 200000000, rate: 0.40 },
+        { from: 200000000, to: 300000000, rate: 0.45 },
+        { from: 300000000, to: 600000000, rate: 0.50 },
+        { from: 600000000, to: null, rate: 0.55 },
+    ],
+};
+
+describe('JapanInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for zero estate', () => {
+        const input: Input = { estateValue: 0, numberOfStatutoryHeirs: 1 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+    });
+
+    it('returns zero tax when estate is below the total exemption (1 heir)', () => {
+        // 1 heir: exemption = 30000000 + 6000000 * 1 = 36000000
+        // estate = 35000000 < 36000000 → no tax
+        const input: Input = { estateValue: 35000000, numberOfStatutoryHeirs: 1 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates tax for estate above the exemption (2 heirs)', () => {
+        // 2 heirs: exemption = 30000000 + 6000000 * 2 = 42000000
+        // taxable = 100000000 - 42000000 = 58000000
+        // 0-10000000: 10000000 * 0.10 = 1000000
+        // 10000000-30000000: 20000000 * 0.15 = 3000000
+        // 30000000-50000000: 20000000 * 0.20 = 4000000
+        // 50000000-58000000: 8000000 * 0.30 = 2400000
+        // Total = 10400000
+        const input: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 2 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.taxableEstate).toBe(58000000);
+        expect(result.inheritanceTax).toBeCloseTo(10400000, 2);
+    });
+
+    it('effective rate equals inheritance tax divided by estate times 100', () => {
+        const input: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 2 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo((result.inheritanceTax / 100000000) * 100, 2);
+    });
+
+    it('more heirs increases the exemption and reduces taxable estate', () => {
+        const input1: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 1 };
+        const input3: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 3 };
+
+        const tax1 = new JapanInheritanceTaxServiceImpl(input1, japanRules).calculate().inheritanceTax;
+        const tax3 = new JapanInheritanceTaxServiceImpl(input3, japanRules).calculate().inheritanceTax;
+
+        expect(tax3).toBeLessThan(tax1);
+    });
+});