Add tests

Author: kappsegla

src/main/java/com/example/Main.java

@@ -0,0 +1,156 @@
+package com.example;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Analyzer class that provides advanced warehouse operations.
+ * Students must implement these methods for the advanced tests to pass.
+ */
+class WarehouseAnalyzer {
+    private final Warehouse warehouse;
+    
+    public WarehouseAnalyzer(Warehouse warehouse) {
+        this.warehouse = warehouse;
+    }
+    
+    // Search and Filter Methods
+    public List<Product> findProductsInPriceRange(BigDecimal minPrice, BigDecimal maxPrice) {
+        // TODO: Implement - should include boundaries (min <= price <= max)
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    public List<Perishable> findProductsExpiringWithinDays(int days) {
+        // TODO: Implement - find products expiring within N days (not already expired)
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    public List<Product> searchProductsByName(String searchTerm) {
+        // TODO: Implement - case-insensitive partial match
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    public List<Product> findProductsAbovePrice(BigDecimal price) {
+        // TODO: Implement
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    // Analytics Methods
+    public Map<Category, BigDecimal> calculateWeightedAveragePriceByCategory() {
+        // TODO: Implement - weighted average based on product weight
+        // For FoodProducts: (sum of price * weight) / (sum of weights)
+        // For other products: simple average
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    public List<Product> findPriceOutliers(double standardDeviations) {
+        // TODO: Implement - find products whose price is more than N standard deviations from mean
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    public List<ShippingGroup> optimizeShippingGroups(BigDecimal maxWeightPerGroup) {
+        // TODO: Implement - group products to minimize shipping costs
+        // Use bin packing algorithm or similar optimization
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    // Business Rules Methods
+    public Map<Product, BigDecimal> calculateExpirationBasedDiscounts() {
+        // TODO: Implement discount rules:
+        // - Expires today: 50% discount
+        // - Expires tomorrow: 30% discount  
+        // - Expires within 3 days: 15% discount
+        // - Otherwise: no discount
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    public InventoryValidation validateInventoryConstraints() {
+        // TODO: Implement validation of business rules
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+    public InventoryStatistics getInventoryStatistics() {
+        // TODO: Implement comprehensive statistics calculation
+        throw new UnsupportedOperationException("Not implemented");
+    }
+}
+
+/**
+ * Represents a group of products for shipping
+ */
+class ShippingGroup {
+    private final List<Shippable> products;
+    private final Double totalWeight;
+    private final BigDecimal totalShippingCost;
+
+    public ShippingGroup(List<Shippable> products) {
+        this.products = new ArrayList<>(products);
+        this.totalWeight = products.stream()
+                .map(Shippable::weight)
+                .reduce(0.0, Double::sum);
+        this.totalShippingCost = products.stream()
+                .map(Shippable::calculateShippingCost)
+                .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
+    public List<Shippable> getProducts() { return new ArrayList<>(products); }
+    public Double getTotalWeight() { return totalWeight; }
+    public BigDecimal getTotalShippingCost() { return totalShippingCost; }
+}
+
+/**
+ * Validation result for inventory constraints
+ */
+class InventoryValidation {
+    private final double highValuePercentage;
+    private final int categoryDiversity;
+    private final boolean highValueWarning;
+    private final boolean minimumDiversity;
+
+    public InventoryValidation(double highValuePercentage, int categoryDiversity) {
+        this.highValuePercentage = highValuePercentage;
+        this.categoryDiversity = categoryDiversity;
+        this.highValueWarning = highValuePercentage > 70.0;
+        this.minimumDiversity = categoryDiversity >= 2;
+    }
+
+    public double getHighValuePercentage() { return highValuePercentage; }
+    public int getCategoryDiversity() { return categoryDiversity; }
+    public boolean isHighValueWarning() { return highValueWarning; }
+    public boolean hasMinimumDiversity() { return minimumDiversity; }
+}
+
+/**
+ * Comprehensive inventory statistics
+ */
+class InventoryStatistics {
+    private final int totalProducts;
+    private final BigDecimal totalValue;
+    private final BigDecimal averagePrice;
+    private final int expiredCount;
+    private final int categoryCount;
+    private final Product mostExpensiveProduct;
+    private final Product cheapestProduct;
+
+    public InventoryStatistics(int totalProducts, BigDecimal totalValue, BigDecimal averagePrice,
+                               int expiredCount, int categoryCount,
+                               Product mostExpensiveProduct, Product cheapestProduct) {
+        this.totalProducts = totalProducts;
+        this.totalValue = totalValue;
+        this.averagePrice = averagePrice;
+        this.expiredCount = expiredCount;
+        this.categoryCount = categoryCount;
+        this.mostExpensiveProduct = mostExpensiveProduct;
+        this.cheapestProduct = cheapestProduct;
+    }
+
+    public int getTotalProducts() { return totalProducts; }
+    public BigDecimal getTotalValue() { return totalValue; }
+    public BigDecimal getAveragePrice() { return averagePrice; }
+    public int getExpiredCount() { return expiredCount; }
+    public int getCategoryCount() { return categoryCount; }
+    public Product getMostExpensiveProduct() { return mostExpensiveProduct; }
+    public Product getCheapestProduct() { return cheapestProduct; }
+}