Jamiir test complete

src/main/java/jamiirparker/TradeTracker.java

@@ -0,0 +1,56 @@
+package jamiirparker;
+
+public class TradeTracker {
+    private String tickerSymbol;
+    private int quantity;
+    private double purchasePrice;
+    private String brokerName;
+    private boolean isActive;
+
+    // Requirement: Constructor taking all fields
+    public TradeTracker(String tickerSymbol, int quantity, double purchasePrice, String brokerName, boolean isActive) {
+        // Requirement: Validation using IllegalArgumentException
+        if (quantity <= 0) {
+            throw new IllegalArgumentException("Quantity must be greater than zero.");
+        }
+        if (purchasePrice < 0) {
+            throw new IllegalArgumentException("Price cannot be negative.");
+        }
+
+        this.tickerSymbol = tickerSymbol;
+        this.quantity = quantity;
+        this.purchasePrice = purchasePrice;
+        this.brokerName = brokerName;
+        this.isActive = isActive;
+    }
+
+    // Requirement: Getters and Setters for all fields
+    public String getTickerSymbol() { return tickerSymbol; }
+    public void setTickerSymbol(String tickerSymbol) { this.tickerSymbol = tickerSymbol; }
+
+    public int getQuantity() { return quantity; }
+    public void setQuantity(int quantity) { this.quantity = quantity; }
+
+    public double getPurchasePrice() { return purchasePrice; }
+    public void setPurchasePrice(double purchasePrice) { this.purchasePrice = purchasePrice; }
+
+    public String getBrokerName() { return brokerName; }
+    public void setBrokerName(String brokerName) { this.brokerName = brokerName; }
+
+    public boolean isActive() { return isActive; }
+    public void setActive(boolean active) { isActive = active; }
+
+    // Requirement: Custom Method 1 - Calculate Total Cost
+    public double getTotalInvestmentValue() {
+        return this.quantity * this.purchasePrice;
+    }
+
+    // Requirement: Custom Method 2 - Calculate Profit/Loss vs Current Price
+    public double calculatePotentialProfit(double currentPrice) {
+        if (currentPrice < 0) {
+            throw new IllegalArgumentException("Current price cannot be negative.");
+        }
+        return (currentPrice - this.purchasePrice) * this.quantity;
+    }
+}
+

src/test/java/jamiirparker/TradeTrackerTest.java

@@ -0,0 +1,111 @@
+package jamiirparker;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class TradeTrackerTest {
+
+    @Test
+    void constructor_HappyPath_SetsAllFields() {
+        // Arrange & Act
+        TradeTracker trade = new TradeTracker("AAPL", 10, 150.0, "E-Trade", true);
+
+        // Assert
+        assertEquals("AAPL", trade.getTickerSymbol());
+        assertEquals(10, trade.getQuantity());
+        assertTrue(trade.isActive());
+    }
+
+    @Test
+    void constructor_InvalidQuantity_ThrowsException() {
+        // Arrange, Act & Assert (Requirement: assertThrows)
+        assertThrows(IllegalArgumentException.class, () -> {
+            new TradeTracker("AAPL", 0, 150.0, "E-Trade", true);
+        });
+    }
+
+    @Test
+    void gettersAndSetters_WorkCorrectly() {
+        // Arrange
+        TradeTracker trade = new TradeTracker("TSLA", 5, 100.0, "Robinhood", true);
+
+        // Act
+        trade.setTickerSymbol("MSFT");
+        trade.setQuantity(20);
+
+        // Assert
+        assertEquals("MSFT", trade.getTickerSymbol());
+        assertEquals(20, trade.getQuantity());
+    }
+
+    @Test
+    void getTotalInvestmentValue_ReturnsCorrectProduct() {
+        // Arrange
+        TradeTracker trade = new TradeTracker("BTC", 2, 50000.0, "Coinbase", true);
+
+        // Act
+        double total = trade.getTotalInvestmentValue();
+
+        // Assert
+        assertEquals(100000.0, total);
+    }
+
+    @Test
+    void calculatePotentialProfit_ReturnsCorrectDifference() {
+        // Arrange
+        TradeTracker trade = new TradeTracker("ETH", 10, 2000.0, "Kraken", true);
+
+        // Act
+        double profit = trade.calculatePotentialProfit(2500.0); // $500 profit per unit * 10
+
+        // Assert
+        assertEquals(5000.0, profit);
+    }
+    @Test
+        void calculatePurchasePrice(){
+        TradeTracker trade = new TradeTracker("ETH", 10, 2000.0, "Kraken", true);
+
+        assertEquals(2000.0,        trade.getPurchasePrice());
+
+
+
+
+
+    }  @Test
+    void calculatesetPrice(){
+        TradeTracker trade = new TradeTracker("ETH", 10, 2000.0, "Kraken", true);
+        trade.setPurchasePrice(50);
+        assertEquals(50,        trade.getPurchasePrice());
+
+
+
+
+
+    }
+    @Test
+    void calculateBrokerName(){
+        TradeTracker trade = new TradeTracker("ETH", 10, 2000.0, "Kraken", true);
+        trade.setBrokerName("Bill");
+        assertEquals("Bill",        trade.getBrokerName());
+
+
+
+
+
+    }
+
+    @Test
+    void calculatesetactive(){
+        TradeTracker trade = new TradeTracker("ETH", 10, 2000.0, "Kraken", true);
+        trade.setActive(true);
+        assertEquals(true,        trade.isActive());
+
+
+
+
+
+    }
+
+
+    }
+