From 2e2217b5a9d6c95d4511af34e03057eb93b3b0b1 Mon Sep 17 00:00:00 2001 From: martin Date: Thu, 5 Mar 2026 19:26:22 +0100 Subject: [PATCH 01/18] Adding single value constructor to Stock --- src/main/java/millions/Stock.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/millions/Stock.java b/src/main/java/millions/Stock.java index 886ecba..ba59d70 100644 --- a/src/main/java/millions/Stock.java +++ b/src/main/java/millions/Stock.java @@ -14,6 +14,12 @@ public Stock(String symbol, String company, List prices) { this.prices = prices; } + public Stock(String symbol, String company, BigDecimal initialPrice) { + this.symbol = symbol; + this.company = company; + this.prices = List.of(initialPrice); + } + public String getSymbol() { return this.symbol; } From 2d2244d8410740512de3b0f2e9ab9aa1609ca5c4 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 10:10:51 +0100 Subject: [PATCH 02/18] adding null check and int quantity overloader --- src/main/java/millions/Exchange.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/main/java/millions/Exchange.java b/src/main/java/millions/Exchange.java index 98584f2..372d44b 100644 --- a/src/main/java/millions/Exchange.java +++ b/src/main/java/millions/Exchange.java @@ -18,6 +18,10 @@ public Exchange(String name, List stockList) { this.stocks = new HashMap<>(); this.weekNumber = 1; + if (name == null || name.isBlank()) { + throw new IllegalArgumentException("Exchange name cannot be null or blank"); + } + // Populate the stocks map to get ticker -> stock for (Stock stock : stockList) { this.stocks.put(stock.getSymbol(), stock); @@ -30,6 +34,10 @@ public void buy(Player player, Stock stock, BigDecimal quantity) { purchase.commit(player); } + public void buy(Player player, Stock stock, int quantity) { + this.buy(player, stock, BigDecimal.valueOf(quantity)); + } + public void sell(Player player, Share share) { Sale sale = new Sale(share, weekNumber); sale.commit(player); From 60d38720f218e402632ff90e122e45062ec04434 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 12:22:18 +0100 Subject: [PATCH 03/18] Changing call order, adding null checks --- src/main/java/millions/Exchange.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/main/java/millions/Exchange.java b/src/main/java/millions/Exchange.java index 372d44b..57d077c 100644 --- a/src/main/java/millions/Exchange.java +++ b/src/main/java/millions/Exchange.java @@ -28,17 +28,23 @@ public Exchange(String name, List stockList) { } } - public void buy(Player player, Stock stock, BigDecimal quantity) { + public void buy(String symbol, Player player, BigDecimal quantity) { + + Stock stock = this.stocks.get(symbol); + if (stock == null) { + throw new IllegalArgumentException("Stock not found"); + } + Share shareToBuy = new Share(stock, quantity, stock.getSalesPrice()); Purchase purchase = new Purchase(shareToBuy, this.weekNumber); purchase.commit(player); } - public void buy(Player player, Stock stock, int quantity) { - this.buy(player, stock, BigDecimal.valueOf(quantity)); + public void buy(String symbol, Player player, int quantity) { + this.buy(symbol, player, BigDecimal.valueOf(quantity)); } - public void sell(Player player, Share share) { + public void sell(Share share, Player player) { Sale sale = new Sale(share, weekNumber); sale.commit(player); } From 945cc6c1b4685389d4191001fc0db3a8e2733add Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 12:22:38 +0100 Subject: [PATCH 04/18] Changing stocks from List to ArrayList --- src/main/java/millions/Stock.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/millions/Stock.java b/src/main/java/millions/Stock.java index ba59d70..41a3ead 100644 --- a/src/main/java/millions/Stock.java +++ b/src/main/java/millions/Stock.java @@ -1,6 +1,7 @@ package millions; import java.math.BigDecimal; +import java.util.ArrayList; import java.util.List; public class Stock { @@ -11,13 +12,13 @@ public class Stock { public Stock(String symbol, String company, List prices) { this.symbol = symbol; this.company = company; - this.prices = prices; + this.prices = new ArrayList<>(prices); } public Stock(String symbol, String company, BigDecimal initialPrice) { this.symbol = symbol; this.company = company; - this.prices = List.of(initialPrice); + this.prices = new ArrayList<>(List.of(initialPrice)); } public String getSymbol() { From 292c14b42d10f1641a4f1f3ab3fd0292212bf706 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 12:23:17 +0100 Subject: [PATCH 05/18] Adding salesPrice and quantity update to calculator --- src/main/java/millions/calculators/SaleCalculator.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/millions/calculators/SaleCalculator.java b/src/main/java/millions/calculators/SaleCalculator.java index 2bddf30..1ceaed6 100644 --- a/src/main/java/millions/calculators/SaleCalculator.java +++ b/src/main/java/millions/calculators/SaleCalculator.java @@ -12,6 +12,8 @@ public class SaleCalculator implements TransactionCalculator { public SaleCalculator(Share share) { super(); this.purchasePrice = share.getPurchasePrice(); + this.salesPrice = share.getStock().getSalesPrice(); + this.quantity = share.getQuantity(); } @Override From 6b33b970c9a6ebb6ca0f2e1d2c2ee75bdc843381 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 12:24:07 +0100 Subject: [PATCH 06/18] test: adding ExchangeTest --- src/test/java/millions/ExchangeTest.java | 80 +++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/ExchangeTest.java b/src/test/java/millions/ExchangeTest.java index a852a0d..f0479b2 100644 --- a/src/test/java/millions/ExchangeTest.java +++ b/src/test/java/millions/ExchangeTest.java @@ -2,4 +2,82 @@ import static org.junit.jupiter.api.Assertions.*; -class ExchangeTest {} +import java.math.BigDecimal; +import java.util.List; +import org.junit.jupiter.api.Test; + +class ExchangeTest { + @Test + public void testGetters() { + Stock s1 = new Stock("PEAR", "Pear Inc.", BigDecimal.valueOf(300)); + Stock s2 = new Stock("DOGL", "DOOGLE Inc.", BigDecimal.valueOf(200.00)); + Stock s3 = new Stock("MSFT", "EpsteinSoft Inc.", BigDecimal.valueOf(0.02)); + + Exchange exchange = new Exchange("exchange", List.of(s1, s2)); + + assertFalse(exchange.hasStock("MSFT")); + assertTrue(exchange.getStock("DOGL").equals(s2)); + assertNull(exchange.getStock("XYZ")); + assertTrue(exchange.findStocks("Amozon").isEmpty()); + + assertTrue(exchange.hasStock("DOGL")); + assertFalse(exchange.findStocks("Pear").isEmpty()); + assertFalse(exchange.findStocks("PE").isEmpty()); + + assertTrue(exchange.findStocks("Inc").size() == 2); + } + + @Test + public void happyPath() { + Stock s1 = new Stock("PEAR", "Pear Inc.", BigDecimal.valueOf(300)); + Stock s2 = new Stock("DOGL", "DOOGLE Inc.", BigDecimal.valueOf(200.00)); + Stock s3 = new Stock("MSFT", "EpsteinSoft Inc.", BigDecimal.valueOf(0.02)); + + Exchange exchange = new Exchange("exchange", List.of(s1, s2, s3)); + Player player = new Player("name", BigDecimal.valueOf(1000)); + + BigDecimal previousMoney = player.getMoney(); + exchange.buy("PEAR", player, 2); + assertTrue(previousMoney.compareTo(player.getMoney()) > 0); + + BigDecimal previousPrice = s1.getSalesPrice(); + exchange.advance(); + assertFalse(previousPrice.equals(s1.getSalesPrice())); + + Share share = player.getPortfolio().getShares().getFirst(); + + previousMoney = player.getMoney(); + exchange.sell(share, player); + assertTrue(previousMoney.compareTo(player.getMoney()) < 0); + assertTrue(player.getPortfolio().getShares().isEmpty()); + } + + @Test + public void testNullsAndInvalid() { + Stock s1 = new Stock("MSFT", "EpsteinSoft Inc.", BigDecimal.valueOf(0.02)); + + Exchange exchange = new Exchange("exchange", List.of(s1)); + Player player = new Player("name", BigDecimal.valueOf(1000)); + + Share unownedShare = new Share(s1, BigDecimal.valueOf(1), s1.getSalesPrice()); + assertThrows(IllegalStateException.class, () -> exchange.sell(unownedShare, player)); + + Player noMoney = new Player("nomoney", BigDecimal.valueOf(0)); + assertThrows(IllegalStateException.class, () -> exchange.buy("MSFT", noMoney, 1)); + + assertThrows( + IllegalArgumentException.class, + () -> new Exchange("", List.of(new Stock("PEAR", "Pear Inc.", BigDecimal.valueOf(300))))); + + assertThrows( + IllegalArgumentException.class, + () -> new Exchange(null, List.of(new Stock("PEAR", "Pear Inc.", BigDecimal.valueOf(300))))); + + assertThrows(IllegalArgumentException.class, () -> exchange.buy("DOGL", player, 2)); + + assertThrows(IllegalArgumentException.class, () -> exchange.buy("DOGL", player, -2)); + + assertThrows( + IllegalArgumentException.class, () -> exchange.buy("DOGL", player, BigDecimal.valueOf(-2))); + } +} From f7e1db69f88ad4de9f43c0bd337d00e124966281 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:14:55 +0100 Subject: [PATCH 07/18] Player adding null and negative checks --- src/main/java/millions/Player.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/main/java/millions/Player.java b/src/main/java/millions/Player.java index 747c8d0..6c01c2c 100644 --- a/src/main/java/millions/Player.java +++ b/src/main/java/millions/Player.java @@ -15,13 +15,27 @@ public Player(String name, BigDecimal startingMoney) { this.money = startingMoney; this.portfolio = new Portfolio(); this.transactionArchive = new TransactionArchive(); + + if (name == null || name.isBlank()) { + throw new IllegalArgumentException("Player name cannot be null or blank"); + } + + if (startingMoney == null || startingMoney.compareTo(BigDecimal.ZERO) < 0) { + throw new IllegalArgumentException("Starting money cannot be null or negative"); + } } public void addMoney(BigDecimal amount) { + if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) { + throw new IllegalArgumentException("Amount cannot be null or negative"); + } this.money = this.money.add(amount); } public void withdrawMoney(BigDecimal amount) { + if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) { + throw new IllegalArgumentException("Amount cannot be null or negative"); + } this.money = this.money.subtract(amount); } From a898b7f722bd727d214a810d405aa42d8bba03c0 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:15:19 +0100 Subject: [PATCH 08/18] Adding int quantity overload for Share --- src/main/java/millions/Share.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/millions/Share.java b/src/main/java/millions/Share.java index 6eddada..afb3947 100644 --- a/src/main/java/millions/Share.java +++ b/src/main/java/millions/Share.java @@ -13,6 +13,10 @@ public Share(Stock stock, BigDecimal quantity, BigDecimal purchasePrice) { this.purchasePrice = purchasePrice; } + public Share(Stock stock, int quantity, BigDecimal purchasePrice) { + this(stock, BigDecimal.valueOf(quantity), purchasePrice); + } + public Stock getStock() { return this.stock; } From e81d68bcadcc848b92a73cd89572152e4cc2d0a6 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:16:17 +0100 Subject: [PATCH 09/18] test: adding playerTest --- src/test/java/millions/PlayerTest.java | 35 +++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/PlayerTest.java b/src/test/java/millions/PlayerTest.java index 62a3263..99cfb45 100644 --- a/src/test/java/millions/PlayerTest.java +++ b/src/test/java/millions/PlayerTest.java @@ -2,4 +2,37 @@ import static org.junit.jupiter.api.Assertions.*; -class PlayerTest {} +import java.math.BigDecimal; +import org.junit.jupiter.api.Test; + +class PlayerTest { + + @Test + public void happyPath() { + Player player = new Player("name", BigDecimal.valueOf(1000)); + assertEquals(BigDecimal.valueOf(1000), player.getMoney()); + + player.addMoney(BigDecimal.valueOf(500)); + assertEquals(BigDecimal.valueOf(1500), player.getMoney()); + + player.withdrawMoney(BigDecimal.valueOf(200)); + assertEquals(BigDecimal.valueOf(1300), player.getMoney()); + } + + @Test + public void testGetters() { + Player player = new Player("name", BigDecimal.valueOf(1000)); + assertEquals("name", player.getName()); + assertEquals(BigDecimal.valueOf(1000), player.getMoney()); + assertTrue(player.getPortfolio().getShares().isEmpty()); + assertTrue(player.getTransactionArchive().isEmpty()); + } + + @Test + public void testNullsAndInvalid() { + assertThrows(IllegalArgumentException.class, () -> new Player(null, BigDecimal.valueOf(1000))); + assertThrows(IllegalArgumentException.class, () -> new Player("", BigDecimal.valueOf(1000))); + assertThrows(IllegalArgumentException.class, () -> new Player("name", null)); + assertThrows(IllegalArgumentException.class, () -> new Player("name", BigDecimal.valueOf(-1))); + } +} From 13001ef77e3f52514eed61af2cf2770cd03332ff Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:16:46 +0100 Subject: [PATCH 10/18] test: adding PortfolioTest --- src/test/java/millions/PortfolioTest.java | 61 ++++++++++++++++++++++- 1 file changed, 60 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/PortfolioTest.java b/src/test/java/millions/PortfolioTest.java index 3fb1019..69bb678 100644 --- a/src/test/java/millions/PortfolioTest.java +++ b/src/test/java/millions/PortfolioTest.java @@ -2,4 +2,63 @@ import static org.junit.jupiter.api.Assertions.*; -class PortfolioTest {} +import java.math.BigDecimal; +import org.junit.jupiter.api.Test; + +class PortfolioTest { + + @Test + public void happyPath() { + Portfolio portfolio = new Portfolio(); + Stock stock = new Stock("PEAR", "Pear Inc.", BigDecimal.valueOf(300)); + Share share = new Share(stock, 10, BigDecimal.valueOf(300)); + + assertTrue(portfolio.addShare(share)); + assertTrue(portfolio.contains(share)); + assertEquals(1, portfolio.getShares().size()); + assertEquals(share, portfolio.getShares().get(0)); + + assertTrue(portfolio.removeShare(share)); + assertFalse(portfolio.contains(share)); + assertTrue(portfolio.getShares().isEmpty()); + } + + @Test + public void testGettersAndSetters() { + Portfolio portfolio = new Portfolio(); + Stock stock1 = new Stock("PEAR", "Pear Inc.", BigDecimal.valueOf(300)); + Stock stock2 = new Stock("DOGL", "DOOGLE Inc.", BigDecimal.valueOf(200.00)); + Share share1 = new Share(stock1, 10, BigDecimal.valueOf(300)); + Share share2 = new Share(stock2, 5, BigDecimal.valueOf(200)); + + portfolio.addShare(share1); + portfolio.addShare(share2); + + assertEquals(2, portfolio.getShares().size()); + assertTrue(portfolio.getShares().contains(share1)); + assertTrue(portfolio.getShares().contains(share2)); + + assertEquals(1, portfolio.getShares("PEAR").size()); + assertTrue(portfolio.getShares("PEAR").contains(share1)); + assertFalse(portfolio.getShares("PEAR").contains(share2)); + + assertEquals(1, portfolio.getShares("DOGL").size()); + assertFalse(portfolio.getShares("DOGL").contains(share1)); + assertTrue(portfolio.getShares("DOGL").contains(share2)); + + assertTrue(portfolio.getShares("XYZ").isEmpty()); + + portfolio.removeShare(share1); + assertEquals(1, portfolio.getShares().size()); + } + + @Test + public void testNullsAndInvalid() { + Stock stock1 = new Stock("PEAR", "Pear Inc.", BigDecimal.valueOf(300)); + Share share1 = new Share(stock1, 10, BigDecimal.valueOf(300)); + Portfolio portfolio = new Portfolio(); + assertFalse(portfolio.removeShare(null)); + assertFalse(portfolio.contains(null)); + assertFalse(portfolio.removeShare(share1)); + } +} From 4e90cef79148719e8bcd3e8f265d22a59f9ea4f8 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:54:39 +0100 Subject: [PATCH 11/18] Adding null checks to Share --- src/main/java/millions/Share.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/millions/Share.java b/src/main/java/millions/Share.java index afb3947..5db6738 100644 --- a/src/main/java/millions/Share.java +++ b/src/main/java/millions/Share.java @@ -11,6 +11,16 @@ public Share(Stock stock, BigDecimal quantity, BigDecimal purchasePrice) { this.stock = stock; this.quantity = quantity; this.purchasePrice = purchasePrice; + + if (stock == null) { + throw new IllegalArgumentException("Stock cannot be null"); + } + if (quantity == null) { + throw new IllegalArgumentException("Quantity cannot be null"); + } + if (purchasePrice == null) { + throw new IllegalArgumentException("Purchase price cannot be null"); + } } public Share(Stock stock, int quantity, BigDecimal purchasePrice) { From eea0cf2b9822ec3330fa5c67d1fcf8cf0507b9a6 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:54:59 +0100 Subject: [PATCH 12/18] Adding null and blank checks to Stock --- src/main/java/millions/Stock.java | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/main/java/millions/Stock.java b/src/main/java/millions/Stock.java index 41a3ead..632c4b7 100644 --- a/src/main/java/millions/Stock.java +++ b/src/main/java/millions/Stock.java @@ -13,12 +13,18 @@ public Stock(String symbol, String company, List prices) { this.symbol = symbol; this.company = company; this.prices = new ArrayList<>(prices); + + if (symbol == null || symbol.isBlank()) { + throw new IllegalArgumentException("Symbol cannot be null or blank"); + } + + if (company == null || company.isBlank()) { + throw new IllegalArgumentException("Company cannot be null or blank"); + } } public Stock(String symbol, String company, BigDecimal initialPrice) { - this.symbol = symbol; - this.company = company; - this.prices = new ArrayList<>(List.of(initialPrice)); + this(symbol, company, new ArrayList<>(List.of(initialPrice))); } public String getSymbol() { From ed67b31e9b372a4645d80cdf99f85903bcc114c5 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:55:37 +0100 Subject: [PATCH 13/18] test: Adding PurchaseTest --- src/test/java/millions/PurchaseTest.java | 37 +++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/PurchaseTest.java b/src/test/java/millions/PurchaseTest.java index a67c37a..4cbb6cc 100644 --- a/src/test/java/millions/PurchaseTest.java +++ b/src/test/java/millions/PurchaseTest.java @@ -2,4 +2,39 @@ import static org.junit.jupiter.api.Assertions.*; -class PurchaseTest {} +import java.math.BigDecimal; +import org.junit.jupiter.api.Test; + +class PurchaseTest { + @Test + public void testHappyPath() { + Stock stock = new Stock("TestStock", "TST", BigDecimal.valueOf(10)); + Share share = new Share(stock, 2, BigDecimal.valueOf(10)); + Player player = new Player("TestPlayer", BigDecimal.valueOf(100)); + Purchase purchase = new Purchase(share, 1); + purchase.commit(player); + assertTrue(purchase.isCommitted()); + + // 1 less because of tax + assertEquals(79, player.getMoney().intValue()); + assertTrue(player.getPortfolio().getShares().contains(share)); + } + + @Test + public void testNullsAndInvalid() { + + Stock stock = new Stock("TestStock", "TST", BigDecimal.valueOf(10)); + Share share = new Share(stock, 2, BigDecimal.valueOf(10)); + Player player = new Player("TestPlayer", BigDecimal.valueOf(100)); + Purchase purchase = new Purchase(share, 1); + + // Double commit + purchase.commit(player); + assertThrows(IllegalStateException.class, () -> purchase.commit(player)); + + // Insufficient funds + Player poorPlayer = new Player("PoorPlayer", BigDecimal.valueOf(10)); + Purchase expensivePurchase = new Purchase(new Share(stock, 20, BigDecimal.valueOf(10)), 1); + assertThrows(IllegalStateException.class, () -> expensivePurchase.commit(poorPlayer)); + } +} From 54bc98cefa569519befcbe1327c6cba345c7c5cd Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 13:55:58 +0100 Subject: [PATCH 14/18] test: Adding SaleTest --- src/test/java/millions/SaleTest.java | 29 +++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/SaleTest.java b/src/test/java/millions/SaleTest.java index b808f7a..a9202b7 100644 --- a/src/test/java/millions/SaleTest.java +++ b/src/test/java/millions/SaleTest.java @@ -2,4 +2,31 @@ import static org.junit.jupiter.api.Assertions.*; -class SaleTest {} +import java.math.BigDecimal; +import org.junit.jupiter.api.Test; + +class SaleTest { + + @Test + public void testHappyPath() { + Stock stock = new Stock("TestStock", "TST", BigDecimal.valueOf(10)); + Share share = new Share(stock, 2, BigDecimal.valueOf(10)); + Player player = new Player("TestPlayer", BigDecimal.valueOf(100)); + player.getPortfolio().addShare(share); + Sale sale = new Sale(share, 1); + sale.commit(player); + assertTrue(sale.isCommitted()); + + assertEquals(120, player.getMoney().intValue()); + assertFalse(player.getPortfolio().getShares().contains(share)); + } + + @Test + public void testNullsAndInvalid() { + Stock stock = new Stock("TestStock", "TST", BigDecimal.valueOf(10)); + Share share = new Share(stock, 2, BigDecimal.valueOf(10)); + Player player = new Player("TestPlayer", BigDecimal.valueOf(100)); + Sale sale = new Sale(share, 1); + assertThrows(IllegalStateException.class, () -> sale.commit(player)); + } +} From 963481b493489465709fb825c756e45ed39de755 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 14:28:47 +0100 Subject: [PATCH 15/18] test: adding ShareTest --- src/test/java/millions/ShareTest.java | 31 ++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/ShareTest.java b/src/test/java/millions/ShareTest.java index cf3d676..0925c5b 100644 --- a/src/test/java/millions/ShareTest.java +++ b/src/test/java/millions/ShareTest.java @@ -2,4 +2,33 @@ import static org.junit.jupiter.api.Assertions.*; -class ShareTest {} +import java.math.BigDecimal; +import org.junit.jupiter.api.Test; + +class ShareTest { + + @Test + public void testHappyPath() { + Stock stock = new Stock("AYO", "Ayhoo", BigDecimal.valueOf(10)); + Share share = new Share(stock, 5, BigDecimal.valueOf(10)); + assertEquals(BigDecimal.valueOf(5), share.getQuantity()); + } + + @Test + public void testGetters() { + Stock stock = new Stock("AYO", "Ayhoo", BigDecimal.valueOf(10)); + Share share = new Share(stock, 5, BigDecimal.valueOf(10)); + assertEquals(BigDecimal.valueOf(5), share.getQuantity()); + assertEquals(stock, share.getStock()); + assertEquals(BigDecimal.valueOf(10), share.getPurchasePrice()); + } + + @Test + public void testNullsAndInvalid() { + Stock stock = new Stock("AYO", "Ayhoo", BigDecimal.valueOf(10)); + assertThrows(IllegalArgumentException.class, () -> new Share(null, 2, BigDecimal.valueOf(2))); + assertThrows(IllegalArgumentException.class, () -> new Share(stock, 2, null)); + assertThrows( + IllegalArgumentException.class, () -> new Share(stock, null, BigDecimal.valueOf(2))); + } +} From d090837b469b46c967f72df623956dcbf72b6111 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 14:29:05 +0100 Subject: [PATCH 16/18] test: adding StockTest --- src/test/java/millions/StockTest.java | 37 ++++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/StockTest.java b/src/test/java/millions/StockTest.java index eda8962..13a95a8 100644 --- a/src/test/java/millions/StockTest.java +++ b/src/test/java/millions/StockTest.java @@ -2,4 +2,39 @@ import static org.junit.jupiter.api.Assertions.*; -class StockTest {} +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; +import org.junit.jupiter.api.Test; + +class StockTest { + @Test + public void testHapyPath() { + Stock stock = new Stock("NVDA", "Nvadia", BigDecimal.valueOf(20)); + Stock stock2 = + new Stock( + "NVDA", "Nvadia", new ArrayList(Arrays.asList(BigDecimal.valueOf(20)))); + stock2.addNewSalesPrice(BigDecimal.valueOf(30)); + assertEquals(BigDecimal.valueOf(30), stock2.getSalesPrice()); + } + + @Test + public void settersAndGetters() { + Stock stock = new Stock("NVDA", "Nvadia", BigDecimal.valueOf(20)); + assertEquals("NVDA", stock.getSymbol()); + assertEquals("Nvadia", stock.getCompany()); + } + + @Test + public void testNullsAndInvalid() { + + assertThrows( + IllegalArgumentException.class, () -> new Stock(null, "Nvadia", BigDecimal.valueOf(20))); + assertThrows( + IllegalArgumentException.class, () -> new Stock("NVDA", null, BigDecimal.valueOf(20))); + assertThrows( + IllegalArgumentException.class, () -> new Stock("NVDA", "", BigDecimal.valueOf(20))); + assertThrows( + IllegalArgumentException.class, () -> new Stock("", "Nvadia", BigDecimal.valueOf(20))); + } +} From 992f8fcdf3b548ca3404370bb36e260ddc184887 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 14:29:33 +0100 Subject: [PATCH 17/18] test: adding TransactionArchiveTest --- .../java/millions/TransactionArchiveTest.java | 43 ++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git a/src/test/java/millions/TransactionArchiveTest.java b/src/test/java/millions/TransactionArchiveTest.java index bdc9ca8..64d1c2c 100644 --- a/src/test/java/millions/TransactionArchiveTest.java +++ b/src/test/java/millions/TransactionArchiveTest.java @@ -2,4 +2,45 @@ import static org.junit.jupiter.api.Assertions.*; -class TransactionArchiveTest {} +import java.math.BigDecimal; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class TransactionArchiveTest { + + TransactionArchive archive; + Purchase purchase; + Sale sale; + + @BeforeEach + public void setUp() { + archive = new TransactionArchive(); + Stock stock = new Stock("SUS", "Samsung", BigDecimal.valueOf(10)); + Share share = new Share(stock, 2, BigDecimal.valueOf(10)); + purchase = new Purchase(share, 1); + sale = new Sale(share, 2); + } + + @Test + public void testHappyPath() { + assertTrue(archive.isEmpty()); + archive.add(purchase); + assertFalse(archive.isEmpty()); + } + + @Test + public void testNullsAndInvalid() { + archive.add(purchase); + assertFalse(archive.add(purchase)); + } + + @Test + public void testGetters() { + archive.add(purchase); + archive.add(sale); + assertEquals(List.of(purchase), archive.getPurchases(1)); + assertEquals(List.of(sale), archive.getSales(2)); + assertEquals(2, archive.countDistinctWeeks()); + } +} From ccce043778f737b6e2cfcd537d24d81b96672aa0 Mon Sep 17 00:00:00 2001 From: martin Date: Fri, 6 Mar 2026 14:30:12 +0100 Subject: [PATCH 18/18] removing test for abstract class --- src/test/java/millions/TransactionTest.java | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 src/test/java/millions/TransactionTest.java diff --git a/src/test/java/millions/TransactionTest.java b/src/test/java/millions/TransactionTest.java deleted file mode 100644 index 9074225..0000000 --- a/src/test/java/millions/TransactionTest.java +++ /dev/null @@ -1,5 +0,0 @@ -package millions; - -import static org.junit.jupiter.api.Assertions.*; - -class TransactionTest {}