atakanwcherry

Name:Unknown

Clan:Unknown

Member Since:Mar 2023

Last Seen:Oct 2025

Profiles:

Following:0

Followers:0

Allies:0

View Profile Badges

Published

atakanwcherryvs.atakanwcherry

Failed Tests

Treasury Settlement Calculation > Python

Code

Diff

from typing import List
from preloaded import TreasuryJob, Transfer, Settlement

class TreasuryService:
    def calculate(self, transfers: List[Transfer]) -> TreasuryJob:
        job = TreasuryJob()
        job.settlements = [] 
        return job

- ##
- from typing import List
- from preloaded import TreasuryJob, Transfer, Settlement
- class TreasuryService:
- def calculate(self, transfers: List[Transfer]) -> TreasuryJob:
- job = TreasuryJob()
- job.settlements = []
- return job

Test Cases

Diff

import unittest
from solution import TreasuryService
from preloaded import Transfer, Settlement, TreasuryJob

class TreasuryTests(unittest.TestCase):

    def test_given_empty_transfer_then_empty_result(self):
        svc = TreasuryService()
        job = svc.calculate([])
        self.assertEqual(len(job.settlements), 0)

    def test_correct_settlement_calculations_single(self):
        transfers = [Transfer("A", "B", 10.0)]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 10.0, places=9)

    def test_correct_settlement_calculations_multi(self):
        transfers = [
            Transfer("A", "B", 10.0),
            Transfer("A", "B", 5.0),
        ]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 15.0, places=9)

    def test_correct_settlement_calculations_opposite_netted(self):
        transfers = [
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0),
        ]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 5.0, places=9)

    def test_correct_settlement_calculations_multiple_transfers(self):
        transfers = [
            Transfer("A", "B", 20.0),
            Transfer("B", "A", 5.0),
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0),
            Transfer("B", "A", 5.0),
        ]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 15.0, places=9)

    def test_correct_settlement_calculations_multiple_accounts(self):
        transfers = [
            Transfer("A", "B", 20.0),
            Transfer("B", "C", 20.0),
            Transfer("C", "D", 20.0),
            Transfer("B", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("D", "B", 10.0),
        ]
        svc = TreasuryService()
        response = svc.calculate(transfers)

        self.assertEqual(len(response.settlements), 5)

        ab = [s for s in response.settlements if s.from_ == "A" and s.to == "B"]
        self.assertTrue(ab, "Expected a settlement A -> B")
        self.assertAlmostEqual(ab[0].amount, 10.0, places=9)

        ba = [s for s in response.settlements if s.from_ == "B" and s.to == "A"]
        self.assertFalse(ba, "Did not expect a settlement B -> A")

        ca = [s for s in response.settlements if s.from_ == "C" and s.to == "A"]
        self.assertTrue(ca, "Expected a settlement C -> A")


if __name__ == "__main__":
    unittest.main()

- //
- import unittest
- from solution import TreasuryService
- from preloaded import Transfer, Settlement, TreasuryJob
- class TreasuryTests(unittest.TestCase):
- def test_given_empty_transfer_then_empty_result(self):
- svc = TreasuryService()
- job = svc.calculate([])
- self.assertEqual(len(job.settlements), 0)
- def test_correct_settlement_calculations_single(self):
- transfers = [Transfer("A", "B", 10.0)]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 10.0, places=9)
- def test_correct_settlement_calculations_multi(self):
- transfers = [
- Transfer("A", "B", 10.0),
- Transfer("A", "B", 5.0),
- ]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 15.0, places=9)
- def test_correct_settlement_calculations_opposite_netted(self):
- transfers = [
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0),
- ]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 5.0, places=9)
- def test_correct_settlement_calculations_multiple_transfers(self):
- transfers = [
- Transfer("A", "B", 20.0),
- Transfer("B", "A", 5.0),
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0),
- Transfer("B", "A", 5.0),
- ]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 15.0, places=9)
- def test_correct_settlement_calculations_multiple_accounts(self):
- transfers = [
- Transfer("A", "B", 20.0),
- Transfer("B", "C", 20.0),
- Transfer("C", "D", 20.0),
- Transfer("B", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("D", "B", 10.0),
- ]
- svc = TreasuryService()
- response = svc.calculate(transfers)
- self.assertEqual(len(response.settlements), 5)
- ab = [s for s in response.settlements if s.from_ == "A" and s.to == "B"]
- self.assertTrue(ab, "Expected a settlement A -> B")
- self.assertAlmostEqual(ab[0].amount, 10.0, places=9)
- ba = [s for s in response.settlements if s.from_ == "B" and s.to == "A"]
- self.assertFalse(ba, "Did not expect a settlement B -> A")
- ca = [s for s in response.settlements if s.from_ == "C" and s.to == "A"]
- self.assertTrue(ca, "Expected a settlement C -> A")
- if __name__ == "__main__":
- unittest.main()

atakanwcherryvs.atakanwcherry

Failed Tests

Treasury Settlement Calculation > TypeScript

Code

Diff

import { TreasuryJob, Transfer, Settlement } from './preloaded'

export class TreasuryService {
  public calculate(transfers: Transfer[]): TreasuryJob {
    const job = new TreasuryJob();
    job.setSettlements([]);
    return job;
  }
}

- ##
- import { TreasuryJob, Transfer, Settlement } from './preloaded'
- export class TreasuryService {
- public calculate(transfers: Transfer[]): TreasuryJob {
- const job = new TreasuryJob();
- job.setSettlements([]);
- return job;
- }
- }

Test Cases

Diff

import { expect } from "chai";
import { TreasuryService } from './solution';
import { TreasuryJob, Transfer, Settlement } from './preloaded'

describe("solution", () => {
  it("Given_Empty_Transfer_Than_Empty_Result_Test", () => {
    const service = new TreasuryService();
    const job = service.calculate([]);
    expect(job.getSettlements().length).to.equal(0);
  });

  it("Correct_Settlement_Calculations_Single_Test", () => {
    const transfers: Transfer[] = [new Transfer("A", "B", 10.0)];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.equal(10.00);
  });

  it("Correct_Settlement_Calculations_Multi_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 10.0),
      new Transfer("A", "B", 5.0),
    ];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.equal(15.00);
  });

  it("Correct_Settlement_Calculations_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 10.0),
      new Transfer("B", "A", 5.0),
    ];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.equal(5.00);
  });

  it("Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 20.0),
      new Transfer("B", "A", 5.0),
      new Transfer("A", "B", 10.0),
      new Transfer("B", "A", 5.0),
      new Transfer("B", "A", 5.0),
    ];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.equal(15.00);
  });

  it("Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 20.0),
      new Transfer("B", "C", 20.0),
      new Transfer("C", "D", 20.0),
      new Transfer("B", "A", 10.0),
      new Transfer("C", "A", 10.0),
      new Transfer("C", "A", 10.0),
      new Transfer("D", "B", 10.0),
    ];

    const service = new TreasuryService();
    const response = service.calculate(transfers);

    expect(response.getSettlements().length).to.equal(5);

    const abSettlement: Settlement | undefined = response
      .getSettlements()
      .find((s) => s.from === "A" && s.to === "B");
    expect(abSettlement).to.not.be.undefined;
    expect(abSettlement!.amount).to.equal(10.0);

    const baSettlement = response
      .getSettlements()
      .find((s) => s.from === "B" && s.to === "A");
    expect(baSettlement).to.be.undefined;

    const acSettlement = response
      .getSettlements()
      .find((s) => s.from === "C" && s.to === "A");
    expect(acSettlement).to.not.be.undefined;
  });
});

- //
- import { expect } from "chai";
- import { TreasuryService } from './solution';
- import { TreasuryJob, Transfer, Settlement } from './preloaded'
- describe("solution", () => {
- it("Given_Empty_Transfer_Than_Empty_Result_Test", () => {
- const service = new TreasuryService();
- const job = service.calculate([]);
- expect(job.getSettlements().length).to.equal(0);
- });
- it("Correct_Settlement_Calculations_Single_Test", () => {
- const transfers: Transfer[] = [new Transfer("A", "B", 10.0)];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.equal(10.00);
- });
- it("Correct_Settlement_Calculations_Multi_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 10.0),
- new Transfer("A", "B", 5.0),
- ];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.equal(15.00);
- });
- it("Correct_Settlement_Calculations_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0),
- ];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.equal(5.00);
- });
- it("Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 20.0),
- new Transfer("B", "A", 5.0),
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0),
- new Transfer("B", "A", 5.0),
- ];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.equal(15.00);
- });
- it("Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 20.0),
- new Transfer("B", "C", 20.0),
- new Transfer("C", "D", 20.0),
- new Transfer("B", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("D", "B", 10.0),
- ];
- const service = new TreasuryService();
- const response = service.calculate(transfers);
- expect(response.getSettlements().length).to.equal(5);
- const abSettlement: Settlement | undefined = response
- .getSettlements()
- .find((s) => s.from === "A" && s.to === "B");
- expect(abSettlement).to.not.be.undefined;
- expect(abSettlement!.amount).to.equal(10.0);
- const baSettlement = response
- .getSettlements()
- .find((s) => s.from === "B" && s.to === "A");
- expect(baSettlement).to.be.undefined;
- const acSettlement = response
- .getSettlements()
- .find((s) => s.from === "C" && s.to === "A");
- expect(acSettlement).to.not.be.undefined;
- });
- });

atakanwcherryvs.atakanwcherry

Failed Tests

Treasury Settlement Calculation > C#

Code

Diff

using System.Collections.Generic;
using System.Linq;

public class TreasuryService
{
    public TreasuryJob Calculate(List<Transfer> transfers) 
    {
        return new TreasuryJob(new List<Settlement>());
    }
}

- ##
- using System.Collections.Generic;
- using System.Linq;
- public class TreasuryService
- {
- public TreasuryJob Calculate(List<Transfer> transfers)
- {
- return new TreasuryJob(new List<Settlement>());
- }
- }

Test Cases

Diff

using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;

[TestFixture]
public class TreasuryServiceTests
{
    [Test]
    public void Given_Empty_Transfer_Than_Empty_Result_Test()
    {
        var treasuryService = new TreasuryService();

        var treasuryJob = treasuryService.Calculate(new List<Transfer>());
        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(0));
    }

    [Test]
    public void Correct_Settlement_Calculations_Single_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 10.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(10.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_Multi_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 10.0),
            new Transfer("A", "B", 5.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 10.0),
            new Transfer("B", "A", 5.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(5.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 20.0),
            new Transfer("B", "A", 5.0),
            new Transfer("A", "B", 10.0),
            new Transfer("B", "A", 5.0),
            new Transfer("B", "A", 5.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 20.0),
            new Transfer("B", "C", 20.0),
            new Transfer("C", "D", 20.0),
            new Transfer("B", "A", 10.0),
            new Transfer("C", "A", 10.0),
            new Transfer("C", "A", 10.0),
            new Transfer("D", "B", 10.0)
        };

        var treasuryService = new TreasuryService();
        var response = treasuryService.Calculate(transfers);

        Assert.That(response.Settlements.Count, Is.EqualTo(5));

        var abSettlement = response.Settlements.FirstOrDefault(s => s.From == "A" && s.To == "B");
        Assert.That(abSettlement, Is.Not.Null);
        Assert.That(abSettlement!.Amount, Is.EqualTo(10.0).Within(1e-9));

        var baSettlement = response.Settlements.FirstOrDefault(s => s.From == "B" && s.To == "A");
        Assert.That(baSettlement, Is.Null);

        var acSettlement = response.Settlements.FirstOrDefault(s => s.From == "C" && s.To == "A");
        Assert.That(acSettlement, Is.Not.Null);
    }
}

- //
- using System.Collections.Generic;
- using System.Linq;
- using NUnit.Framework;
- [TestFixture]
- public class TreasuryServiceTests
- {
- [Test]
- public void Given_Empty_Transfer_Than_Empty_Result_Test()
- {
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(new List<Transfer>());
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(0));
- }
- [Test]
- public void Correct_Settlement_Calculations_Single_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 10.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(10.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_Multi_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 10.0),
- new Transfer("A", "B", 5.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(5.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 20.0),
- new Transfer("B", "A", 5.0),
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0),
- new Transfer("B", "A", 5.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 20.0),
- new Transfer("B", "C", 20.0),
- new Transfer("C", "D", 20.0),
- new Transfer("B", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("D", "B", 10.0)
- };
- var treasuryService = new TreasuryService();
- var response = treasuryService.Calculate(transfers);
- Assert.That(response.Settlements.Count, Is.EqualTo(5));
- var abSettlement = response.Settlements.FirstOrDefault(s => s.From == "A" && s.To == "B");
- Assert.That(abSettlement, Is.Not.Null);
- Assert.That(abSettlement!.Amount, Is.EqualTo(10.0).Within(1e-9));
- var baSettlement = response.Settlements.FirstOrDefault(s => s.From == "B" && s.To == "A");
- Assert.That(baSettlement, Is.Null);
- var acSettlement = response.Settlements.FirstOrDefault(s => s.From == "C" && s.To == "A");
- Assert.That(acSettlement, Is.Not.Null);
- }
- }

atakanwcherryvs.atakanwcherry

Failed Tests

Treasury Settlement Calculation > Kotlin

Code

Diff

class TreasuryService {
    fun calculate(transfers: List<Transfer>): TreasuryJob {
        val job = TreasuryJob()
        job.setSettlements(mutableListOf())
        return job
    }
}

- ##
- class TreasuryService {
- fun calculate(transfers: List<Transfer>): TreasuryJob {
- val job = TreasuryJob()
- job.setSettlements(mutableListOf())
- return job
- }
- }

Test Cases

Diff

import org.junit.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertNull

class TreasuryTest {

    @Test
    fun Given_Empty_Transfer_Than_Empty_Result_Test() {
        val treasuryService = TreasuryService()

        val treasuryJob = treasuryService.calculate(listOf())
        assertEquals(0, treasuryJob.getSettlements()?.size)
    }

    @Test
    fun Correct_Settlement_Calculations_Single_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 10.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(10.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_Multi_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 10.0),
            Transfer("A", "B", 5.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(5.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 20.0),
            Transfer("B", "A", 5.0),
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0),
            Transfer("B", "A", 5.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 20.0),
            Transfer("B", "C", 20.0),
            Transfer("C", "D", 20.0),
            Transfer("B", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("D", "B", 10.0)
        )

        val treasuryService = TreasuryService()
        val response = treasuryService.calculate(transfers)

        assertEquals(5, response.getSettlements()?.size)

        val abSettlement = response.getSettlements()?.firstOrNull {
            it.from == "A" && it.to == "B"
        }
        assertNotNull(abSettlement)
        assertEquals(10.0, abSettlement.amount)

        val baSettlement = response.getSettlements()?.firstOrNull {
            it.from == "B" && it.to == "A"
        }
        assertNull(baSettlement)

        val acSettlement = response.getSettlements()?.firstOrNull {
            it.from == "C" && it.to == "A"
        }
        assertNotNull(acSettlement)
    }
}

- //
- import org.junit.Test
- import kotlin.test.assertEquals
- import kotlin.test.assertNotNull
- import kotlin.test.assertNull
- class TreasuryTest {
- @Test
- fun Given_Empty_Transfer_Than_Empty_Result_Test() {
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(listOf())
- assertEquals(0, treasuryJob.getSettlements()?.size)
- }
- @Test
- fun Correct_Settlement_Calculations_Single_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 10.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(10.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_Multi_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 10.0),
- Transfer("A", "B", 5.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(5.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 20.0),
- Transfer("B", "A", 5.0),
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0),
- Transfer("B", "A", 5.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 20.0),
- Transfer("B", "C", 20.0),
- Transfer("C", "D", 20.0),
- Transfer("B", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("D", "B", 10.0)
- )
- val treasuryService = TreasuryService()
- val response = treasuryService.calculate(transfers)
- assertEquals(5, response.getSettlements()?.size)
- val abSettlement = response.getSettlements()?.firstOrNull {
- it.from == "A" && it.to == "B"
- }
- assertNotNull(abSettlement)
- assertEquals(10.0, abSettlement.amount)
- val baSettlement = response.getSettlements()?.firstOrNull {
- it.from == "B" && it.to == "A"
- }
- assertNull(baSettlement)
- val acSettlement = response.getSettlements()?.firstOrNull {
- it.from == "C" && it.to == "A"
- }
- assertNotNull(acSettlement)
- }
- }

atakanwcherryvs.atakanwcherry

Failed Tests

Treasury Settlement Calculation > Java

Code

Diff

import java.util.ArrayList;
import java.util.List;

public class TreasuryService {
    public TreasuryJob calculate(List<Transfer> transfers) {
        TreasuryJob job = new TreasuryJob();
        job.setSettlements(new ArrayList<>());
        return job;
    }
}

- ##
- import java.util.ArrayList;
- import java.util.List;
- public class TreasuryService {
- public TreasuryJob calculate(List<Transfer> transfers) {
- TreasuryJob job = new TreasuryJob();
- job.setSettlements(new ArrayList<>());
- return job;
- }
- }

Test Cases

Diff

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

import static junit.framework.TestCase.*;

public class TreasuryTest {
    @Test
    public void Given_Empty_Transfer_Than_Empty_Result_Test() {
        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(List.of());
        assertEquals(0, treasuryJob.getSettlements().size());
    }

    @Test
    public void Correct_Settlement_Calculations_Single_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 10.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(10.0, treasuryJob.getSettlements().get(0).amount);
    }
  

    @Test
    public void Correct_Settlement_Calculations_Multi_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 10.0));
        transfers.add(new Transfer("A", "B", 5.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
    }

    @Test
    public void Correct_Settlement_Calculations_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 10.0));
        transfers.add(new Transfer("B", "A", 5.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(5.0, treasuryJob.getSettlements().get(0).amount);
    }

    @Test
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 20.0));
        transfers.add(new Transfer("B", "A", 5.0));
        transfers.add(new Transfer("A", "B", 10.0));
        transfers.add(new Transfer("B", "A", 5.0));
        transfers.add(new Transfer("B", "A", 5.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
    }

    @Test
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 20.0));
        transfers.add(new Transfer("B", "C", 20.0));
        transfers.add(new Transfer("C", "D", 20.0));
        transfers.add(new Transfer("B", "A", 10.0));
        transfers.add(new Transfer("C", "A", 10.0));
        transfers.add(new Transfer("C", "A", 10.0));
        transfers.add(new Transfer("D", "B", 10.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob response = treasuryService.calculate(transfers);
        assertEquals(5, response.getSettlements().size());

        Settlement abSettlement = response.getSettlements().stream().filter(settlement -> {
            boolean b = Objects.equals(settlement.from, "A") && Objects.equals(settlement.to, "B");
            return b;
        }).findFirst().orElse(null);

        assertNotNull(abSettlement);
        assertEquals(10.0, abSettlement.amount);

        Settlement baSettlement = response.getSettlements().stream().filter(settlement -> {
            boolean b = Objects.equals(settlement.from, "B") && Objects.equals(settlement.to, "A");
            return b;
        }).findFirst().orElse(null);

        assertNull(baSettlement);

        Settlement acSettlement = response.getSettlements().stream().filter(settlement -> {
            boolean b = Objects.equals(settlement.from, "C") && Objects.equals(settlement.to, "A");
            return b;
        }).findFirst().orElse(null);

        assertNotNull(acSettlement);
    }
}

- //
- import org.junit.Test;
- import java.util.ArrayList;
- import java.util.List;
- import java.util.Objects;
- import java.util.Optional;
- import static junit.framework.TestCase.*;
- public class TreasuryTest {
- @Test
- public void Given_Empty_Transfer_Than_Empty_Result_Test() {
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(List.of());
- assertEquals(0, treasuryJob.getSettlements().size());
- }
- @Test
- public void Correct_Settlement_Calculations_Single_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 10.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(10.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_Multi_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 10.0));
- transfers.add(new Transfer("A", "B", 5.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 10.0));
- transfers.add(new Transfer("B", "A", 5.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(5.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 20.0));
- transfers.add(new Transfer("B", "A", 5.0));
- transfers.add(new Transfer("A", "B", 10.0));
- transfers.add(new Transfer("B", "A", 5.0));
- transfers.add(new Transfer("B", "A", 5.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 20.0));
- transfers.add(new Transfer("B", "C", 20.0));
- transfers.add(new Transfer("C", "D", 20.0));
- transfers.add(new Transfer("B", "A", 10.0));
- transfers.add(new Transfer("C", "A", 10.0));
- transfers.add(new Transfer("C", "A", 10.0));
- transfers.add(new Transfer("D", "B", 10.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob response = treasuryService.calculate(transfers);
- assertEquals(5, response.getSettlements().size());
- Settlement abSettlement = response.getSettlements().stream().filter(settlement -> {
- boolean b = Objects.equals(settlement.from, "A") && Objects.equals(settlement.to, "B");
- return b;
- }).findFirst().orElse(null);
- assertNotNull(abSettlement);
- assertEquals(10.0, abSettlement.amount);
- Settlement baSettlement = response.getSettlements().stream().filter(settlement -> {
- boolean b = Objects.equals(settlement.from, "B") && Objects.equals(settlement.to, "A");
- return b;
- }).findFirst().orElse(null);
- assertNull(baSettlement);
- Settlement acSettlement = response.getSettlements().stream().filter(settlement -> {
- boolean b = Objects.equals(settlement.from, "C") && Objects.equals(settlement.to, "A");
- return b;
- }).findFirst().orElse(null);
- assertNotNull(acSettlement);
- }
- }

atakanwcherry

Failed Tests

Treasury Settlement Calculation

Story:

Imagine you and your friends are constantly sending each other money during the day. For example: Alice pays Bob for lunch, Bob pays Charlie for coffee, and so on. At the end of the day, instead of remembering every single transfer, you just want to know the final balance. We call this the settlement problem.

Task:

Write a function calculate(transfers) that takes a list of transfers between people and produces a simplified list of settlements.

A Transfer means one person gave money to another.
A Settlement means the final simplified result of all transfers between two people.

The function should combine multiple transfers in the same direction, and net out opposite transfers (so we don't list both A → B and B → A, only the final difference).

Input:

A list of Transfer objects.

Each transfer has:
- from (string) – the sender's name
- to (string) – the receiver's name
- amount (number) – how much money was sent

Output:

A TreasuryJob object containing a list of Settlement objects.

Each settlement has:
- from (string) – who finally owes
- to (string) – who should receive
- amount (number) – the net amount

Rules:

Combine transfers in the same direction.
- e.g. Alice → Bob: 10 and Alice → Bob: 5 → Alice → Bob: 15
Net opposite transfers.
- e.g. Alice → Bob: 10 and Bob → Alice: 7 → Alice → Bob: 3
  
  or equivalently:
- e.g. Alice → Bob: 10 and Bob → Alice: 7 → Bob → Alice: -3
Keeping 0 amounts is allowed.
- e.g. Alice → Bob: 5 and Bob → Alice: 5 → Alice → Bob: 0

##

//

atakanwcherryvs.atakanwcherry

Failed Tests

Transfer - Treasury Settlement Calculation > Python

Code

Diff

from typing import List
from preloaded import TreasuryJob, Transfer, Settlement

class TreasuryService:
    def calculate(self, transfers: List[Transfer]) -> TreasuryJob:
        job = TreasuryJob()
        job.settlements = [] 
        return job

- ##
- from typing import List
- from preloaded import TreasuryJob, Transfer, Settlement
- class TreasuryService:
- def calculate(self, transfers: List[Transfer]) -> TreasuryJob:
- job = TreasuryJob()
- job.settlements = []
- return job

Test Cases

Diff

import unittest
from solution import TreasuryService
from preloaded import Transfer, Settlement, TreasuryJob

class TreasuryTests(unittest.TestCase):

    def test_given_empty_transfer_then_empty_result(self):
        svc = TreasuryService()
        job = svc.calculate([])
        self.assertEqual(len(job.settlements), 0)

    def test_correct_settlement_calculations_single(self):
        transfers = [Transfer("A", "B", 10.0)]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 10.0, places=9)

    def test_correct_settlement_calculations_multi(self):
        transfers = [
            Transfer("A", "B", 10.0),
            Transfer("A", "B", 5.0),
        ]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 15.0, places=9)

    def test_correct_settlement_calculations_opposite_netted(self):
        transfers = [
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0),
        ]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 5.0, places=9)

    def test_correct_settlement_calculations_multiple_transfers(self):
        transfers = [
            Transfer("A", "B", 20.0),
            Transfer("B", "A", 5.0),
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0),
            Transfer("B", "A", 5.0),
        ]
        svc = TreasuryService()
        job = svc.calculate(transfers)

        self.assertEqual(len(job.settlements), 1)
        s = job.settlements[0]
        self.assertEqual(s.from_, "A")
        self.assertEqual(s.to, "B")
        self.assertAlmostEqual(s.amount, 15.0, places=9)

    def test_correct_settlement_calculations_multiple_accounts(self):
        transfers = [
            Transfer("A", "B", 20.0),
            Transfer("B", "C", 20.0),
            Transfer("C", "D", 20.0),
            Transfer("B", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("D", "B", 10.0),
        ]
        svc = TreasuryService()
        response = svc.calculate(transfers)

        self.assertEqual(len(response.settlements), 5)

        ab = [s for s in response.settlements if s.from_ == "A" and s.to == "B"]
        self.assertTrue(ab, "Expected a settlement A -> B")
        self.assertAlmostEqual(ab[0].amount, 10.0, places=9)

        ba = [s for s in response.settlements if s.from_ == "B" and s.to == "A"]
        self.assertFalse(ba, "Did not expect a settlement B -> A")

        ca = [s for s in response.settlements if s.from_ == "C" and s.to == "A"]
        self.assertTrue(ca, "Expected a settlement C -> A")


if __name__ == "__main__":
    unittest.main()

- ~~test~~
- import unittest
- from solution import TreasuryService
- from preloaded import Transfer, Settlement, TreasuryJob
- class TreasuryTests(unittest.TestCase):
- def test_given_empty_transfer_then_empty_result(self):
- svc = TreasuryService()
- job = svc.calculate([])
- self.assertEqual(len(job.settlements), 0)
- def test_correct_settlement_calculations_single(self):
- transfers = [Transfer("A", "B", 10.0)]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 10.0, places=9)
- def test_correct_settlement_calculations_multi(self):
- transfers = [
- Transfer("A", "B", 10.0),
- Transfer("A", "B", 5.0),
- ]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 15.0, places=9)
- def test_correct_settlement_calculations_opposite_netted(self):
- transfers = [
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0),
- ]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 5.0, places=9)
- def test_correct_settlement_calculations_multiple_transfers(self):
- transfers = [
- Transfer("A", "B", 20.0),
- Transfer("B", "A", 5.0),
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0),
- Transfer("B", "A", 5.0),
- ]
- svc = TreasuryService()
- job = svc.calculate(transfers)
- self.assertEqual(len(job.settlements), 1)
- s = job.settlements[0]
- self.assertEqual(s.from_, "A")
- self.assertEqual(s.to, "B")
- self.assertAlmostEqual(s.amount, 15.0, places=9)
- def test_correct_settlement_calculations_multiple_accounts(self):
- transfers = [
- Transfer("A", "B", 20.0),
- Transfer("B", "C", 20.0),
- Transfer("C", "D", 20.0),
- Transfer("B", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("D", "B", 10.0),
- ]
- svc = TreasuryService()
- response = svc.calculate(transfers)
- self.assertEqual(len(response.settlements), 5)
- ab = [s for s in response.settlements if s.from_ == "A" and s.to == "B"]
- self.assertTrue(ab, "Expected a settlement A -> B")
- self.assertAlmostEqual(ab[0].amount, 10.0, places=9)
- ba = [s for s in response.settlements if s.from_ == "B" and s.to == "A"]
- self.assertFalse(ba, "Did not expect a settlement B -> A")
- ca = [s for s in response.settlements if s.from_ == "C" and s.to == "A"]
- self.assertTrue(ca, "Expected a settlement C -> A")
- if __name__ == "__main__":
- unittest.main()

atakanwcherryvs.atakanwcherry

Failed Tests

Transfer - Treasury Settlement Calculation > Typescript

Code

Diff

import { TreasuryJob, Transfer, Settlement } from './preloaded'

export class TreasuryService {
  public calculate(transfers: Transfer[]): TreasuryJob {
    const job = new TreasuryJob();
    job.setSettlements([]);
    return job;
  }
}

- ##
- import { TreasuryJob, Transfer, Settlement } from './preloaded'
- export class TreasuryService {
- public calculate(transfers: Transfer[]): TreasuryJob {
- const job = new TreasuryJob();
- job.setSettlements([]);
- return job;
- }
- }

Test Cases

Diff

import { expect } from "chai";
import { TreasuryService } from './solution';
import { TreasuryJob, Transfer, Settlement } from './preloaded'

describe("solution", () => {
  it("Given_Empty_Transfer_Than_Empty_Result_Test", () => {
    const service = new TreasuryService();
    const job = service.calculate([]);
    expect(job.getSettlements().length).to.equal(0);
  });

  it("Correct_Settlement_Calculations_Single_Test", () => {
    const transfers: Transfer[] = [new Transfer("A", "B", 10.0)];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.be.closeTo(10.0, 1e-9);
  });

  it("Correct_Settlement_Calculations_Multi_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 10.0),
      new Transfer("A", "B", 5.0),
    ];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.be.closeTo(15.0, 1e-9);
  });

  it("Correct_Settlement_Calculations_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 10.0),
      new Transfer("B", "A", 5.0),
    ];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.be.closeTo(5.0, 1e-9);
  });

  it("Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 20.0),
      new Transfer("B", "A", 5.0),
      new Transfer("A", "B", 10.0),
      new Transfer("B", "A", 5.0),
      new Transfer("B", "A", 5.0),
    ];
    const service = new TreasuryService();
    const job = service.calculate(transfers);

    expect(job.getSettlements().length).to.equal(1);
    expect(job.getSettlements()[0].from).to.equal("A");
    expect(job.getSettlements()[0].to).to.equal("B");
    expect(job.getSettlements()[0].amount).to.be.closeTo(15.0, 1e-9);
  });

  it("Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test", () => {
    const transfers: Transfer[] = [
      new Transfer("A", "B", 20.0),
      new Transfer("B", "C", 20.0),
      new Transfer("C", "D", 20.0),
      new Transfer("B", "A", 10.0),
      new Transfer("C", "A", 10.0),
      new Transfer("C", "A", 10.0),
      new Transfer("D", "B", 10.0),
    ];

    const service = new TreasuryService();
    const response = service.calculate(transfers);

    expect(response.getSettlements().length).to.equal(5);

    const abSettlement: Settlement | undefined = response
      .getSettlements()
      .find((s) => s.from === "A" && s.to === "B");
    expect(abSettlement).to.not.be.undefined;
    expect(abSettlement!.amount).to.be.closeTo(10.0, 1e-9);

    const baSettlement = response
      .getSettlements()
      .find((s) => s.from === "B" && s.to === "A");
    expect(baSettlement).to.be.undefined;

    const acSettlement = response
      .getSettlements()
      .find((s) => s.from === "C" && s.to === "A");
    expect(acSettlement).to.not.be.undefined;
  });
});

- ~~test~~
- import { expect } from "chai";
- import { TreasuryService } from './solution';
- import { TreasuryJob, Transfer, Settlement } from './preloaded'
- describe("solution", () => {
- it("Given_Empty_Transfer_Than_Empty_Result_Test", () => {
- const service = new TreasuryService();
- const job = service.calculate([]);
- expect(job.getSettlements().length).to.equal(0);
- });
- it("Correct_Settlement_Calculations_Single_Test", () => {
- const transfers: Transfer[] = [new Transfer("A", "B", 10.0)];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.be.closeTo(10.0, 1e-9);
- });
- it("Correct_Settlement_Calculations_Multi_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 10.0),
- new Transfer("A", "B", 5.0),
- ];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.be.closeTo(15.0, 1e-9);
- });
- it("Correct_Settlement_Calculations_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0),
- ];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.be.closeTo(5.0, 1e-9);
- });
- it("Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 20.0),
- new Transfer("B", "A", 5.0),
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0),
- new Transfer("B", "A", 5.0),
- ];
- const service = new TreasuryService();
- const job = service.calculate(transfers);
- expect(job.getSettlements().length).to.equal(1);
- expect(job.getSettlements()[0].from).to.equal("A");
- expect(job.getSettlements()[0].to).to.equal("B");
- expect(job.getSettlements()[0].amount).to.be.closeTo(15.0, 1e-9);
- });
- it("Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test", () => {
- const transfers: Transfer[] = [
- new Transfer("A", "B", 20.0),
- new Transfer("B", "C", 20.0),
- new Transfer("C", "D", 20.0),
- new Transfer("B", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("D", "B", 10.0),
- ];
- const service = new TreasuryService();
- const response = service.calculate(transfers);
- expect(response.getSettlements().length).to.equal(5);
- const abSettlement: Settlement | undefined = response
- .getSettlements()
- .find((s) => s.from === "A" && s.to === "B");
- expect(abSettlement).to.not.be.undefined;
- expect(abSettlement!.amount).to.be.closeTo(10.0, 1e-9);
- const baSettlement = response
- .getSettlements()
- .find((s) => s.from === "B" && s.to === "A");
- expect(baSettlement).to.be.undefined;
- const acSettlement = response
- .getSettlements()
- .find((s) => s.from === "C" && s.to === "A");
- expect(acSettlement).to.not.be.undefined;
- });
- });

atakanwcherryvs.atakanwcherry

Failed Tests

Transfer - Treasury Settlement Calculation > .Net

Code

Diff

using System.Collections.Generic;
using System.Linq;

public class TreasuryService
{
    public TreasuryJob Calculate(List<Transfer> transfers) 
    {
        return new TreasuryJob(new List<Settlement>());
    }
}

- ##
- using System.Collections.Generic;
- using System.Linq;
- public class TreasuryService
- {
- public TreasuryJob Calculate(List<Transfer> transfers)
- {
- return new TreasuryJob(new List<Settlement>());
- }
- }

Test Cases

Diff

using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;

[TestFixture]
public class TreasuryServiceTests
{
    [Test]
    public void Given_Empty_Transfer_Than_Empty_Result_Test()
    {
        var treasuryService = new TreasuryService();

        var treasuryJob = treasuryService.Calculate(new List<Transfer>());
        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(0));
    }

    [Test]
    public void Correct_Settlement_Calculations_Single_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 10.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(10.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_Multi_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 10.0),
            new Transfer("A", "B", 5.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 10.0),
            new Transfer("B", "A", 5.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(5.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 20.0),
            new Transfer("B", "A", 5.0),
            new Transfer("A", "B", 10.0),
            new Transfer("B", "A", 5.0),
            new Transfer("B", "A", 5.0)
        };

        var treasuryService = new TreasuryService();
        var treasuryJob = treasuryService.Calculate(transfers);

        Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
        Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
        Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
        Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
    }

    [Test]
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test()
    {
        var transfers = new List<Transfer>
        {
            new Transfer("A", "B", 20.0),
            new Transfer("B", "C", 20.0),
            new Transfer("C", "D", 20.0),
            new Transfer("B", "A", 10.0),
            new Transfer("C", "A", 10.0),
            new Transfer("C", "A", 10.0),
            new Transfer("D", "B", 10.0)
        };

        var treasuryService = new TreasuryService();
        var response = treasuryService.Calculate(transfers);

        Assert.That(response.Settlements.Count, Is.EqualTo(5));

        var abSettlement = response.Settlements.FirstOrDefault(s => s.From == "A" && s.To == "B");
        Assert.That(abSettlement, Is.Not.Null);
        Assert.That(abSettlement!.Amount, Is.EqualTo(10.0).Within(1e-9));

        var baSettlement = response.Settlements.FirstOrDefault(s => s.From == "B" && s.To == "A");
        Assert.That(baSettlement, Is.Null);

        var acSettlement = response.Settlements.FirstOrDefault(s => s.From == "C" && s.To == "A");
        Assert.That(acSettlement, Is.Not.Null);
    }
}

- ~~test~~
- using System.Collections.Generic;
- using System.Linq;
- using NUnit.Framework;
- [TestFixture]
- public class TreasuryServiceTests
- {
- [Test]
- public void Given_Empty_Transfer_Than_Empty_Result_Test()
- {
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(new List<Transfer>());
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(0));
- }
- [Test]
- public void Correct_Settlement_Calculations_Single_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 10.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(10.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_Multi_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 10.0),
- new Transfer("A", "B", 5.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(5.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 20.0),
- new Transfer("B", "A", 5.0),
- new Transfer("A", "B", 10.0),
- new Transfer("B", "A", 5.0),
- new Transfer("B", "A", 5.0)
- };
- var treasuryService = new TreasuryService();
- var treasuryJob = treasuryService.Calculate(transfers);
- Assert.That(treasuryJob.Settlements.Count, Is.EqualTo(1));
- Assert.That(treasuryJob.Settlements[0].From, Is.EqualTo("A"));
- Assert.That(treasuryJob.Settlements[0].To, Is.EqualTo("B"));
- Assert.That(treasuryJob.Settlements[0].Amount, Is.EqualTo(15.0).Within(1e-9));
- }
- [Test]
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test()
- {
- var transfers = new List<Transfer>
- {
- new Transfer("A", "B", 20.0),
- new Transfer("B", "C", 20.0),
- new Transfer("C", "D", 20.0),
- new Transfer("B", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("C", "A", 10.0),
- new Transfer("D", "B", 10.0)
- };
- var treasuryService = new TreasuryService();
- var response = treasuryService.Calculate(transfers);
- Assert.That(response.Settlements.Count, Is.EqualTo(5));
- var abSettlement = response.Settlements.FirstOrDefault(s => s.From == "A" && s.To == "B");
- Assert.That(abSettlement, Is.Not.Null);
- Assert.That(abSettlement!.Amount, Is.EqualTo(10.0).Within(1e-9));
- var baSettlement = response.Settlements.FirstOrDefault(s => s.From == "B" && s.To == "A");
- Assert.That(baSettlement, Is.Null);
- var acSettlement = response.Settlements.FirstOrDefault(s => s.From == "C" && s.To == "A");
- Assert.That(acSettlement, Is.Not.Null);
- }
- }

atakanwcherryvs.atakanwcherry

Failed Tests

Transfer - Treasury Settlement Calculation > Kotlin

Code

Diff

class TreasuryService {
    fun calculate(transfers: List<Transfer>): TreasuryJob {
        val job = TreasuryJob()
        job.setSettlements(mutableListOf())
        return job
    }
}

- ##
- class TreasuryService {
- fun calculate(transfers: List<Transfer>): TreasuryJob {
- val job = TreasuryJob()
- job.setSettlements(mutableListOf())
- return job
- }
- }

Test Cases

Diff

import org.junit.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertNull

class TreasuryTest {

    @Test
    fun Given_Empty_Transfer_Than_Empty_Result_Test() {
        val treasuryService = TreasuryService()

        val treasuryJob = treasuryService.calculate(listOf())
        assertEquals(0, treasuryJob.getSettlements()?.size)
    }

    @Test
    fun Correct_Settlement_Calculations_Single_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 10.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(10.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_Multi_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 10.0),
            Transfer("A", "B", 5.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(5.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 20.0),
            Transfer("B", "A", 5.0),
            Transfer("A", "B", 10.0),
            Transfer("B", "A", 5.0),
            Transfer("B", "A", 5.0)
        )

        val treasuryService = TreasuryService()
        val treasuryJob = treasuryService.calculate(transfers)

        assertEquals(1, treasuryJob.getSettlements()?.size)
        assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
        assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
        assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
    }

    @Test
    fun Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
        val transfers = arrayListOf(
            Transfer("A", "B", 20.0),
            Transfer("B", "C", 20.0),
            Transfer("C", "D", 20.0),
            Transfer("B", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("C", "A", 10.0),
            Transfer("D", "B", 10.0)
        )

        val treasuryService = TreasuryService()
        val response = treasuryService.calculate(transfers)

        assertEquals(5, response.getSettlements()?.size)

        val abSettlement = response.getSettlements()?.firstOrNull {
            it.from == "A" && it.to == "B"
        }
        assertNotNull(abSettlement)
        assertEquals(10.0, abSettlement.amount)

        val baSettlement = response.getSettlements()?.firstOrNull {
            it.from == "B" && it.to == "A"
        }
        assertNull(baSettlement)

        val acSettlement = response.getSettlements()?.firstOrNull {
            it.from == "C" && it.to == "A"
        }
        assertNotNull(acSettlement)
    }
}

- ~~test~~
- import org.junit.Test
- import kotlin.test.assertEquals
- import kotlin.test.assertNotNull
- import kotlin.test.assertNull
- class TreasuryTest {
- @Test
- fun Given_Empty_Transfer_Than_Empty_Result_Test() {
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(listOf())
- assertEquals(0, treasuryJob.getSettlements()?.size)
- }
- @Test
- fun Correct_Settlement_Calculations_Single_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 10.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(10.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_Multi_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 10.0),
- Transfer("A", "B", 5.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(5.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 20.0),
- Transfer("B", "A", 5.0),
- Transfer("A", "B", 10.0),
- Transfer("B", "A", 5.0),
- Transfer("B", "A", 5.0)
- )
- val treasuryService = TreasuryService()
- val treasuryJob = treasuryService.calculate(transfers)
- assertEquals(1, treasuryJob.getSettlements()?.size)
- assertEquals("A", treasuryJob.getSettlements()?.get(0)?.from)
- assertEquals("B", treasuryJob.getSettlements()?.get(0)?.to)
- assertEquals(15.0, treasuryJob.getSettlements()?.get(0)?.amount)
- }
- @Test
- fun Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
- val transfers = arrayListOf(
- Transfer("A", "B", 20.0),
- Transfer("B", "C", 20.0),
- Transfer("C", "D", 20.0),
- Transfer("B", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("C", "A", 10.0),
- Transfer("D", "B", 10.0)
- )
- val treasuryService = TreasuryService()
- val response = treasuryService.calculate(transfers)
- assertEquals(5, response.getSettlements()?.size)
- val abSettlement = response.getSettlements()?.firstOrNull {
- it.from == "A" && it.to == "B"
- }
- assertNotNull(abSettlement)
- assertEquals(10.0, abSettlement.amount)
- val baSettlement = response.getSettlements()?.firstOrNull {
- it.from == "B" && it.to == "A"
- }
- assertNull(baSettlement)
- val acSettlement = response.getSettlements()?.firstOrNull {
- it.from == "C" && it.to == "A"
- }
- assertNotNull(acSettlement)
- }
- }

atakanwcherryvs.atakanwcherry

Failed Tests

Transfer - Treasury Settlement Calculation > Java

Code

Diff

import java.util.ArrayList;
import java.util.List;

public class TreasuryService {
    public TreasuryJob calculate(List<Transfer> transfers) {
        TreasuryJob job = new TreasuryJob();
        job.setSettlements(new ArrayList<>());
        return job;
    }
}

- ##
- import java.util.ArrayList;
- import java.util.List;
- public class TreasuryService {
- public TreasuryJob calculate(List<Transfer> transfers) {
- TreasuryJob job = new TreasuryJob();
- job.setSettlements(new ArrayList<>());
- return job;
- }
- }

Test Cases

Diff

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

import static junit.framework.TestCase.*;

public class TreasuryTest {
    @Test
    public void Given_Empty_Transfer_Than_Empty_Result_Test() {
        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(List.of());
        assertEquals(0, treasuryJob.getSettlements().size());
    }

    @Test
    public void Correct_Settlement_Calculations_Single_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 10.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(10.0, treasuryJob.getSettlements().get(0).amount);
    }
  

    @Test
    public void Correct_Settlement_Calculations_Multi_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 10.0));
        transfers.add(new Transfer("A", "B", 5.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
    }

    @Test
    public void Correct_Settlement_Calculations_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 10.0));
        transfers.add(new Transfer("B", "A", 5.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(5.0, treasuryJob.getSettlements().get(0).amount);
    }

    @Test
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 20.0));
        transfers.add(new Transfer("B", "A", 5.0));
        transfers.add(new Transfer("A", "B", 10.0));
        transfers.add(new Transfer("B", "A", 5.0));
        transfers.add(new Transfer("B", "A", 5.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob treasuryJob = treasuryService.calculate(transfers);
        assertEquals(1, treasuryJob.getSettlements().size());
        assertEquals("A", treasuryJob.getSettlements().get(0).from);
        assertEquals("B", treasuryJob.getSettlements().get(0).to);
        assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
    }

    @Test
    public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
        ArrayList<Transfer> transfers = new ArrayList<>();
        transfers.add(new Transfer("A", "B", 20.0));
        transfers.add(new Transfer("B", "C", 20.0));
        transfers.add(new Transfer("C", "D", 20.0));
        transfers.add(new Transfer("B", "A", 10.0));
        transfers.add(new Transfer("C", "A", 10.0));
        transfers.add(new Transfer("C", "A", 10.0));
        transfers.add(new Transfer("D", "B", 10.0));

        TreasuryService treasuryService = new TreasuryService();

        TreasuryJob response = treasuryService.calculate(transfers);
        assertEquals(5, response.getSettlements().size());

        Settlement abSettlement = response.getSettlements().stream().filter(settlement -> {
            boolean b = Objects.equals(settlement.from, "A") && Objects.equals(settlement.to, "B");
            return b;
        }).findFirst().orElse(null);

        assertNotNull(abSettlement);
        assertEquals(10.0, abSettlement.amount);

        Settlement baSettlement = response.getSettlements().stream().filter(settlement -> {
            boolean b = Objects.equals(settlement.from, "B") && Objects.equals(settlement.to, "A");
            return b;
        }).findFirst().orElse(null);

        assertNull(baSettlement);

        Settlement acSettlement = response.getSettlements().stream().filter(settlement -> {
            boolean b = Objects.equals(settlement.from, "C") && Objects.equals(settlement.to, "A");
            return b;
        }).findFirst().orElse(null);

        assertNotNull(acSettlement);
    }
}

- ~~test~~
- import org.junit.Test;
- import java.util.ArrayList;
- import java.util.List;
- import java.util.Objects;
- import java.util.Optional;
- import static junit.framework.TestCase.*;
- public class TreasuryTest {
- @Test
- public void Given_Empty_Transfer_Than_Empty_Result_Test() {
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(List.of());
- assertEquals(0, treasuryJob.getSettlements().size());
- }
- @Test
- public void Correct_Settlement_Calculations_Single_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 10.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(10.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_Multi_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 10.0));
- transfers.add(new Transfer("A", "B", 5.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 10.0));
- transfers.add(new Transfer("B", "A", 5.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(5.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Transfers_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 20.0));
- transfers.add(new Transfer("B", "A", 5.0));
- transfers.add(new Transfer("A", "B", 10.0));
- transfers.add(new Transfer("B", "A", 5.0));
- transfers.add(new Transfer("B", "A", 5.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob treasuryJob = treasuryService.calculate(transfers);
- assertEquals(1, treasuryJob.getSettlements().size());
- assertEquals("A", treasuryJob.getSettlements().get(0).from);
- assertEquals("B", treasuryJob.getSettlements().get(0).to);
- assertEquals(15.0, treasuryJob.getSettlements().get(0).amount);
- }
- @Test
- public void Correct_Settlement_Calculations_When_There_Are_Multiple_Accounts_Test() {
- ArrayList<Transfer> transfers = new ArrayList<>();
- transfers.add(new Transfer("A", "B", 20.0));
- transfers.add(new Transfer("B", "C", 20.0));
- transfers.add(new Transfer("C", "D", 20.0));
- transfers.add(new Transfer("B", "A", 10.0));
- transfers.add(new Transfer("C", "A", 10.0));
- transfers.add(new Transfer("C", "A", 10.0));
- transfers.add(new Transfer("D", "B", 10.0));
- TreasuryService treasuryService = new TreasuryService();
- TreasuryJob response = treasuryService.calculate(transfers);
- assertEquals(5, response.getSettlements().size());
- Settlement abSettlement = response.getSettlements().stream().filter(settlement -> {
- boolean b = Objects.equals(settlement.from, "A") && Objects.equals(settlement.to, "B");
- return b;
- }).findFirst().orElse(null);
- assertNotNull(abSettlement);
- assertEquals(10.0, abSettlement.amount);
- Settlement baSettlement = response.getSettlements().stream().filter(settlement -> {
- boolean b = Objects.equals(settlement.from, "B") && Objects.equals(settlement.to, "A");
- return b;
- }).findFirst().orElse(null);
- assertNull(baSettlement);
- Settlement acSettlement = response.getSettlements().stream().filter(settlement -> {
- boolean b = Objects.equals(settlement.from, "C") && Objects.equals(settlement.to, "A");
- return b;
- }).findFirst().orElse(null);
- assertNotNull(acSettlement);
- }
- }

atakanwcherry

Failed Tests

Transfer - Treasury Settlement Calculation

##
test

Confirm

Collect: kata

You have not created any collections yet.