Changes according to the review comments,

Added test cases.

.gitignore

+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+build/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
\ No newline at end of file

build.gradle

@@ -2,7 +2,7 @@ plugins {
     id 'java'
 }
 
-group 'org.example'
+group 'com.retailstore.ordermanagement'
 version '1.0-SNAPSHOT'
 
 repositories {
@@ -19,6 +19,8 @@ dependencies {
     annotationProcessor 'org.projectlombok:lombok:1.18.22'
     // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api
     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.8.2'
+// https://mvnrepository.com/artifact/org.mockito/mockito-core
+    testImplementation group: 'org.mockito', name: 'mockito-inline', version: '3.4.4'
 }
 
 test {

src/main/java/com/retailstore/ordermanagement/application/OrderManagement.java

-package com.retail_store.order_management.application;
+package com.retailstore.ordermanagement.application;
 
-import com.retail_store.order_management.service.RetailStore;
-import com.retail_store.order_management.service.RetailStoreService;
+import com.retailstore.ordermanagement.service.RetailStoreService;
+import com.retailstore.ordermanagement.service.RetailStoreServiceImpl;
+import com.retailstore.ordermanagement.utils.DBUtil;
+import lombok.extern.java.Log;
 
+import java.sql.SQLException;
 import java.util.Scanner;
-import java.util.logging.Logger;
 
-import static com.retail_store.order_management.utils.Utility.getInt;
+import static com.retailstore.ordermanagement.utils.InputUtil.validateInputNumber;
 
 /**
  * The project run starts from here
  */
+@Log
 public class OrderManagement {
     private Scanner scanner;
-    private final Logger logger;
 
     /**
      * No-Arg Constructor for class OrderManagement with their private
@@ -23,7 +25,6 @@ public class OrderManagement {
         System.setProperty("java.util.logging.SimpleFormatter.format",
                 "%5$s %n");
         this.scanner = new Scanner(System.in);
-        this.logger = Logger.getLogger(OrderManagement.class.getName());
     }
 
     /**
@@ -40,44 +41,49 @@ public class OrderManagement {
         String enterForMenu = "Please enter 5 for menu";
 
         boolean flag = true;
-        logger.info("Welcome to RetailStore Business Management");
-        RetailStore gap = new RetailStoreService();
+        log.info("Welcome to RetailStore Business Management");
+        RetailStoreService gap = new RetailStoreServiceImpl();
         String menu = "\n------------------------\nMenu\n------------------------\n" +
                 option1 + "\n------------------------\n" +
                 option2 + "\n------------------------\n" +
                 option3 + "\n------------------------\n" +
                 option4;
-        logger.info(menu);
+        log.info(menu);
         while (flag) {
             int menuOption;
-            menuOption = getInt();
+            menuOption = validateInputNumber();
             switch (menuOption) {
                 case 1:
                     gap.addProducts();
-                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
-                            "To exit please enter 4\n------------------------\n" +
-                            "To Add more enter 1\n------------------------\n");
+                    log.info("\n------------------------\n" + enterForMenu + "\n------------------------\n" +
+                            toExit + "\n------------------------\n" +
+                            toAddMore + "\n------------------------\n");
                     break;
                 case 2:
                     gap.placeOrders();
-                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
-                            "To exit please enter 4");
+                    log.info("\n------------------------\n" + enterForMenu + "\n------------------------\n" +
+                            toExit);
                     break;
                 case 3:
                     gap.showOrders();
-                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
-                            "To exit please enter 4");
+                    log.info("\n------------------------\n" + enterForMenu + "\n------------------------\n" +
+                            toExit);
                     break;
                 case 4:
-                    logger.info("Good Bye.");
+                    log.info("Good Bye.");
                     flag = false;
+                    try {
+                        DBUtil.getConnection().close();
+                    } catch (SQLException e) {
+                        log.warning(e.getMessage());
+                    }
                     break;
                 case 5:
-                    logger.info(menu);
+                    log.info(menu);
                     break;
                 default:
-                    logger.warning("\n------------------------\nPlease enter valid menu option\n------------------------\n");
-                    logger.info(menu);
+                    log.warning("\n------------------------\nPlease enter valid menu option\n------------------------\n");
+                    log.info(menu);
             }
         }
     }

src/main/java/com/retailstore/ordermanagement/constants/Category.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Here using Enum class types as the requirement has constants to

src/main/java/com/retailstore/ordermanagement/constants/Color.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Enumeration class of name Color

src/main/java/com/retailstore/ordermanagement/constants/Gender.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Enumeration class of name Gender
@@ -11,7 +11,7 @@ public enum Gender {
      */
     EXIT(0, "exit"), MEN(1, "Men"), WOMEN(2, "Women");
     int option;
-    String gender;
+    String getName;
 
     /**
      * Method is used to return option value
@@ -30,7 +30,7 @@ public enum Gender {
      * @return
      */
     public String getGender() {
-        return gender;
+        return getName;
     }
 
     /**
@@ -41,6 +41,6 @@ public enum Gender {
      */
     Gender(int option, String gender) {
         this.option = option;
-        this.gender = gender;
+        this.getName = gender;
     }
 }

src/main/java/com/retailstore/ordermanagement/constants/Size.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Enumeration class name Size

src/main/java/com/retailstore/ordermanagement/model/Order.java

-package com.retail_store.order_management.model;
+package com.retailstore.ordermanagement.model;
 
 import lombok.AllArgsConstructor;
 import lombok.Builder;

src/main/java/com/retailstore/ordermanagement/model/OrderedProduct.java

-package com.retail_store.order_management.model;
+package com.retailstore.ordermanagement.model;
 
 
-import com.retail_store.order_management.constants.Category;
-import com.retail_store.order_management.constants.Color;
-import com.retail_store.order_management.constants.Gender;
-import com.retail_store.order_management.constants.Size;
+import com.retailstore.ordermanagement.constants.Category;
+import com.retailstore.ordermanagement.constants.Color;
+import com.retailstore.ordermanagement.constants.Gender;
+import com.retailstore.ordermanagement.constants.Size;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 

src/main/java/com/retailstore/ordermanagement/model/Product.java

-package com.retail_store.order_management.model;
+package com.retailstore.ordermanagement.model;
 
 
-import com.retail_store.order_management.constants.Category;
-import com.retail_store.order_management.constants.Color;
-import com.retail_store.order_management.constants.Gender;
-import com.retail_store.order_management.constants.Size;
+import com.retailstore.ordermanagement.constants.Category;
+import com.retailstore.ordermanagement.constants.Color;
+import com.retailstore.ordermanagement.constants.Gender;
+import com.retailstore.ordermanagement.constants.Size;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 

src/main/java/com/retailstore/ordermanagement/service/ProductService.java

@@ -14,7 +14,7 @@ import java.util.Map;
  * This is an interface to filter the products according to
  * respective of taken methods in this interface
  */
-public interface ProductFilter {
+public interface ProductService {
     /**
      * This is an abstract method gives the
      * categories of product according selection of gender type

src/main/java/com/retailstore/ordermanagement/service/RetailStoreService.java

@@ -12,7 +12,7 @@ import java.util.Collection;
  * In this interface there present different abstract methods to perform
  * various functions of the project
  */
-public interface RetailStore {
+public interface RetailStoreService {
     /**
      * This abstract method is used to add the products seemly according to the
      * given process in the console, if added then shows message accordingly

src/main/java/com/retailstore/ordermanagement/service/RetailStoreServiceImpl.java

@@ -7,14 +7,24 @@ import com.retailstore.ordermanagement.constants.Size;
 import com.retailstore.ordermanagement.model.Order;
 import com.retailstore.ordermanagement.model.OrderedProduct;
 import com.retailstore.ordermanagement.model.Product;
-import com.retailstore.ordermanagement.utils.Database;
-import com.retailstore.ordermanagement.utils.Utility;
+import com.retailstore.ordermanagement.utils.DBUtil;
+import com.retailstore.ordermanagement.utils.InputUtil;
+import lombok.extern.java.Log;
 
 import java.sql.Date;
-import java.sql.*;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
 import java.time.LocalDate;
 import java.time.LocalTime;
-import java.util.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.LinkedHashMap;
+import java.util.Collection;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
@@ -22,30 +32,30 @@ import java.util.concurrent.atomic.AtomicInteger;
  * This class implements from previous interfaces RetailStore and ProductFilter so
  * that all the unimplemented methods should be implemented here and given there logic inside
  */
-public class RetailStoreService implements RetailStore, ProductFilter {
+@Log
+public class RetailStoreServiceImpl implements RetailStoreService, ProductService {
 
     public boolean addProducts() {
         boolean productAdded = false;
-        String id = Utility.productIdGenerator();
-        Utility.getLogger().info("Enter Product details \n Enter Product Name");
-        String name = Utility.getScanner().nextLine();
-        Category category = Utility.getCategory(true, "Enter Product Category");
+        String id = InputUtil.productIdGenerator();
+        log.info("Enter Product details \n Enter Product Name");
+        String name = InputUtil.getScanner().nextLine();
+        Category category = InputUtil.getCategory(true, "Enter Product Category");
         if (category == null) {
             return false;
         }
-        Color color = Utility.getColor(true, "Select color of the product");
-        if (category == null) {
+        Color color = InputUtil.getColor(true, "Select color of the product");
+        if (color == null) {
             return false;
         }
-        Gender gender = Utility.getGender(true, "Product is ideal for");
-        if (category == null) {
+        Gender gender = InputUtil.getGender(true, "Product is ideal for");
+        if (gender == null) {
             return false;
         }
-        double price = Utility.getDouble(true, "Enter price of the product");
-        Map<Size, Integer> size = Utility.getProductSizes();
-        Connection connection = Database.getConnection();
-        try {
-            PreparedStatement preparedStatement = connection.prepareStatement("insert into products values(?,?,?,?,?,?,?,?,?,?,?)");
+        double price = InputUtil.validateInputPrice(true, "Enter price of the product");
+        Map<Size, Integer> size = InputUtil.getProductSizes();
+        Connection connection = DBUtil.getConnection();
+        try (PreparedStatement preparedStatement = connection.prepareStatement("insert into products values(?,?,?,?,?,?,?,?,?,?,?)");) {
             preparedStatement.setString(1, id);
             preparedStatement.setString(2, name);
             preparedStatement.setString(3, category.toString());
@@ -59,22 +69,22 @@ public class RetailStoreService implements RetailStore, ProductFilter {
             preparedStatement.setInt(11, size.get(Size.XXL));
             productAdded = preparedStatement.executeUpdate() > 0;
             if (productAdded) {
-                Utility.getLogger().info("Your product with name : " + name + " is added successfully");
+                log.info("Your product with name : " + name + " is added successfully");
             } else {
-                Utility.getLogger().info("Your product is not added successfully");
+                log.info("Your product is not added successfully");
                 productAdded = addProducts();
             }
         } catch (SQLException e) {
-            Utility.getScanner().reset();
-            Utility.getLogger().warning(e.getMessage());
-            Utility.getLogger().warning("Your product is not added successfully");
+            InputUtil.getScanner().reset();
+            log.warning(e.getMessage());
+            log.warning("Your product is not added successfully");
             productAdded = addProducts();
         }
         return productAdded;
     }
 
     public boolean placeOrders() {
-        Connection connection = Database.getConnection();
+        Connection connection = DBUtil.getConnection();
         int confirmOrder;
         String orderMessage;
         try {
@@ -82,20 +92,20 @@ public class RetailStoreService implements RetailStore, ProductFilter {
 
             List<OrderedProduct> orderedProductList = createOrder(connection);
             if (orderedProductList == null || orderedProductList.isEmpty()) {
-                Utility.getLogger().info("Since your order list is empty, unable to place order\n To make an order please enter 1\n Press any number to exit");
-                int option = Utility.getInt();
+                log.info("Since your order list is empty, unable to place order\n To make an order please enter 1\n Press any number to exit");
+                int option = InputUtil.validateInputNumber();
                 if (option == 1) {
                     return placeOrders();
                 } else {
-                    Utility.getScanner().reset();
+                    InputUtil.getScanner().reset();
                     return false;
                 }
             }
-            String orderId = Utility.orderIdGenerator();
-            Utility.getLogger().info("Please enter Customer name");
-            String name = Utility.getScanner().nextLine();
-            Utility.getLogger().info("Please enter Phone number");
-            String phone = Utility.phoneNumberValidator();
+            String orderId = InputUtil.orderIdGenerator();
+            log.info("Please enter Customer name");
+            String name = InputUtil.getScannerLine();
+            log.info("Please enter Phone number");
+            String phone = InputUtil.phoneNumberValidator();
             Date date = Date.valueOf(LocalDate.now());
             Time time = Time.valueOf(LocalTime.now());
             double bill = orderedProductList.stream().map(product -> product.getPrice() * product.getQuantity()).reduce(0.00, (totalBill, productBill) -> totalBill + productBill);
@@ -123,25 +133,25 @@ public class RetailStoreService implements RetailStore, ProductFilter {
                 }
                 preparedStatement.executeBatch();
             }
-            Utility.getLogger().info("to confirm the order enter 1\n to cancel enter any number");
-            confirmOrder = Utility.getScanner().nextInt();
+            log.info("to confirm the order enter 1\n to cancel enter any number");
+            confirmOrder = InputUtil.getScanner().nextInt();
             switch (confirmOrder) {
                 case 1:
-                    Utility.getLogger().info("Your order is successfully placed.");
-                    Utility.getLogger().info(orderMessage);
+                    log.info("Your order is successfully placed.");
+                    log.info(orderMessage);
                     connection.commit();
                     break;
                 default:
-                    Utility.getLogger().info("Your order is not confirmed");
+                    log.info("Your order is not confirmed");
                     connection.rollback();
             }
             return true;
         } catch (Exception e) {
-            Utility.getLogger().warning(e.getMessage());
+            log.warning(e.getMessage());
             try {
                 connection.rollback();
             } catch (Exception ex) {
-                Utility.getLogger().warning(ex.getMessage());
+                log.warning(ex.getMessage());
             }
             return true;
         }
@@ -152,8 +162,8 @@ public class RetailStoreService implements RetailStore, ProductFilter {
         List<OrderedProduct> cart = new ArrayList<>();
         boolean orderBoolean = true;
         while (orderBoolean) {
-            Utility.getLogger().info("********************GAP********************* " + "\n \t (1) Men  \t \t \t \t (2) Women\n-----------------------------\nto exit enter 0\n-----------------------------\n");
-            Gender gender = Utility.getGender(false, "Please select...");
+            log.info("********************GAP********************* " + "\n \t (1) Men  \t \t \t \t (2) Women\n-----------------------------\nto exit enter 0\n-----------------------------\n");
+            Gender gender = InputUtil.getGender(false, "Please select...");
             if (gender == Gender.EXIT) {
                 cart = null;
                 break;
@@ -161,8 +171,8 @@ public class RetailStoreService implements RetailStore, ProductFilter {
             boolean genderBoolean = true;
             while (genderBoolean) {
                 Map<Integer, Category> categoryMenu = getCategoriesByGender(gender);
-                Utility.getLogger().info("\n-----------------------------\nSelect the category\n-----------------------------\nTo change the gender please enter 0");
-                int categoryMenuNumber = Utility.getInt();
+                log.info("\n-----------------------------\nSelect the category\n-----------------------------\nTo change the gender please enter 0");
+                int categoryMenuNumber = InputUtil.validateInputNumber();
                 Category category = categoryMenu.get(categoryMenuNumber);
                 if (category == null) {
                     break;
@@ -170,8 +180,8 @@ public class RetailStoreService implements RetailStore, ProductFilter {
                 boolean categoryBoolean = true;
                 while (categoryBoolean) {
                     Map<Integer, Product> productsByGenderAndCategory = getProductsByGenderAndCategory(gender, category);
-                    Utility.getLogger().info("\n-----------------------------\nSelect the product\n-----------------------------\nTo change the category please enter 0");
-                    int productMenuNumber = Utility.getInt();
+                    log.info("\n-----------------------------\nSelect the product\n-----------------------------\nTo change the category please enter 0");
+                    int productMenuNumber = InputUtil.validateInputNumber();
                     Product product = productsByGenderAndCategory.get(productMenuNumber);
                     if (product == null) {
                         break;
@@ -179,14 +189,14 @@ public class RetailStoreService implements RetailStore, ProductFilter {
                     if (!addProductToCart(cart, product, connection)) {
                         continue;
                     } else {
-                        Utility.getLogger().info("\n-----------------------------\nYour product : " + product.getName() + " is added to your cart.\n-----------------------------\n");
+                        log.info("\n-----------------------------\nYour product : " + product.getName() + " is added to your cart.\n-----------------------------\n");
                     }
                     boolean menuFlag = true;
-                    Utility.getLogger().info("\n-----------------------------\nPlease enter 1 - to continue the shopping" +
+                    log.info("\n-----------------------------\nPlease enter 1 - to continue the shopping" +
                             "\n-----------------------------\nEnter 2 to place the order" +
                             "\n-----------------------------\nEnter 3 to go back");
                     while (menuFlag) {
-                        int order = Utility.getInt();
+                        int order = InputUtil.validateInputNumber();
                         switch (order) {
                             case 1:
                                 categoryBoolean = false;
@@ -207,7 +217,7 @@ public class RetailStoreService implements RetailStore, ProductFilter {
                                 orderBoolean = false;
                                 break;
                             default:
-                                Utility.getLogger().info("\n-----------------------------\nPlease enter valid option\n-----------------------------\n");
+                                log.info("\n-----------------------------\nPlease enter valid option\n-----------------------------\n");
                                 createOrder(connection);
                         }
                     }
@@ -220,36 +230,35 @@ public class RetailStoreService implements RetailStore, ProductFilter {
     @Override
     public synchronized boolean addProductToCart(Collection<OrderedProduct> cart, Product product, Connection connection) {
         if (product.outOfStock()) {
-            Utility.getLogger().info("\n-----------------------------\nSorry to say this. Currently this product was out of stock.\n-----------------------------\n");
+            log.info("\n-----------------------------\nSorry to say this. Currently this product was out of stock.\n-----------------------------\n");
             return false;
         }
-        Utility.getLogger().info(product.showSizes());
-        Size size = Utility.getSize(true, "Please Select Size");
+        log.info(product.showSizes());
+        Size size = InputUtil.getSize(true, "Please Select Size");
         if (size == null) {
             return false;
         }
-        Utility.getLogger().info("\n-----------------------------\nPlease enter quantity required\n-----------------------------\n");
-        int quantity = Utility.getInt();
+        log.info("\n-----------------------------\nPlease enter quantity required\n-----------------------------\n");
+        int quantity = InputUtil.validateInputNumber();
         if (quantity <= 0) {
-            Utility.getLogger().info("\n-----------------------------\nPlease enter atleast 1 quantity.\n-----------------------------\n");
+            log.info("\n-----------------------------\nPlease enter atleast 1 quantity.\n-----------------------------\n");
             return false;
         }
         int availableQuantity = product.getSize().get(size);
         if (quantity <= availableQuantity) {
             int remaining = availableQuantity - quantity;
-            try {
-                PreparedStatement preparedStatement = connection.prepareStatement("update gap.products set " + size.getName() + "=? where id =?");
+            try (PreparedStatement preparedStatement = connection.prepareStatement("update gap.products set " + size.getName() + "=? where id =?");) {
                 preparedStatement.setInt(1, remaining);
                 preparedStatement.setString(2, product.getId());
                 preparedStatement.executeUpdate();
             } catch (SQLException e) {
-                Utility.getLogger().warning("\n-----------------------------\nUnable to add product to cart\n-----------------------------\n");
-                Utility.getLogger().warning(e.getMessage());
+                log.warning("\n-----------------------------\nUnable to add product to cart\n-----------------------------\n");
+                log.warning(e.getMessage());
                 return addProductToCart(cart, product, connection);
             }
             return cart.add(new OrderedProduct(product.getId(), product.getName(), product.getCategory(), product.getColor(), product.getPrice(), product.getIdealFor(), size, quantity));
         } else {
-            Utility.getLogger().warning("\n-----------------------------\nplease enter quantity less or equal to the stock available\n-----------------------------\n");
+            log.warning("\n-----------------------------\nplease enter quantity less or equal to the stock available\n-----------------------------\n");
             return addProductToCart(cart, product, connection);
         }
     }
@@ -258,24 +267,23 @@ public class RetailStoreService implements RetailStore, ProductFilter {
     public LinkedHashMap<Integer, Category> getCategoriesByGender(Gender gender) {
         LinkedHashMap<Integer, Category> categoryMap = new LinkedHashMap<>();
         AtomicInteger number = new AtomicInteger(0);
-        Connection connection = Database.getConnection();
-        try {
-            PreparedStatement preparedStatement = connection.prepareStatement("select category from gap.products where gender=? group by category");
+        Connection connection = DBUtil.getConnection();
+        try (PreparedStatement preparedStatement = connection.prepareStatement("select category from gap.products where gender=? group by category");) {
             preparedStatement.setString(1, gender.getGender());
             ResultSet resultSet = preparedStatement.executeQuery();
             while (resultSet.next()) {
                 categoryMap.put(number.incrementAndGet(), Category.valueOf(resultSet.getString(1)));
             }
         } catch (SQLException e) {
-            Utility.getLogger().warning(e.getMessage());
-            Utility.getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
+            log.warning(e.getMessage());
+            log.warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
             return getCategoriesByGender(gender);
         }
         if (categoryMap.isEmpty()) {
-            Utility.getLogger().info("\n-----------------------------\nCategories not found in " + gender + "\n-----------------------------\n");
+            log.info("\n-----------------------------\nCategories not found in " + gender + "\n-----------------------------\n");
         } else {
             String menu = categoryMap.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue()).reduce("", (categories, category) -> categories + "\n" + category);
-            Utility.getLogger().info(menu);
+            log.info(menu);
         }
         return categoryMap;
     }
@@ -284,27 +292,26 @@ public class RetailStoreService implements RetailStore, ProductFilter {
     public Map<Integer, Product> getProductsByGenderAndCategory(Gender gender, Category category) {
         Map<Integer, Product> productMap = new LinkedHashMap<>();
         AtomicInteger number = new AtomicInteger(0);
-        Connection connection = Database.getConnection();
-        try {
-            PreparedStatement preparedStatement = connection.prepareStatement("select * from gap.products where gender=? and category =?");
+        Connection connection = DBUtil.getConnection();
+        try (PreparedStatement preparedStatement = connection.prepareStatement("select * from gap.products where gender=? and category =?");) {
             preparedStatement.setString(1, gender.getGender());
             preparedStatement.setString(2, category.toString());
             ResultSet resultSet = preparedStatement.executeQuery();
             ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
             while (resultSet.next()) {
-                Product product = new Product(resultSet.getString(1), resultSet.getString(2), Category.valueOf(resultSet.getString(3)), Color.valueOf(resultSet.getString(4)), resultSet.getDouble(5), Gender.valueOf(resultSet.getString(6).toUpperCase()), Utility.getProductSizes(resultSet.getInt(7), resultSet.getInt(8), resultSet.getInt(9), resultSet.getInt(10), resultSet.getInt(11)));
+                Product product = new Product(resultSet.getString(1), resultSet.getString(2), Category.valueOf(resultSet.getString(3)), Color.valueOf(resultSet.getString(4)), resultSet.getDouble(5), Gender.valueOf(resultSet.getString(6).toUpperCase()), InputUtil.getProductSizes(resultSet.getInt(7), resultSet.getInt(8), resultSet.getInt(9), resultSet.getInt(10), resultSet.getInt(11)));
                 productMap.put(number.incrementAndGet(), product);
             }
         } catch (SQLException e) {
-            Utility.getLogger().warning(e.getMessage());
-            Utility.getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
+            log.warning(e.getMessage());
+            log.warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
             return getProductsByGenderAndCategory(gender, category);
         }
         if (productMap.isEmpty()) {
-            Utility.getLogger().info("\n-----------------------------\nProducts not found in " + category + "\n-----------------------------\n");
+            log.info("\n-----------------------------\nProducts not found in " + category + "\n-----------------------------\n");
         } else {
             String menu = productMap.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue().productShowcaseInMenu()).reduce("", (products, product) -> products + "\n" + product);
-            Utility.getLogger().info(menu);
+            log.info(menu);
         }
         return productMap;
     }
@@ -313,9 +320,8 @@ public class RetailStoreService implements RetailStore, ProductFilter {
     public Map<Integer, Color> getColorsByGenderAndCategory(Gender gender, Category category) {
         Map<Integer, Color> colorMap = new LinkedHashMap<>();
         AtomicInteger number = new AtomicInteger(0);
-        Connection connection = Database.getConnection();
-        try {
-            PreparedStatement preparedStatement = connection.prepareStatement("select color from gap.products where gender=? and category=? group by color");
+        Connection connection = DBUtil.getConnection();
+        try (PreparedStatement preparedStatement = connection.prepareStatement("select color from gap.products where gender=? and category=? group by color")) {
             preparedStatement.setString(1, gender.getGender());
             preparedStatement.setString(2, category.toString());
             ResultSet resultSet = preparedStatement.executeQuery();
@@ -323,15 +329,15 @@ public class RetailStoreService implements RetailStore, ProductFilter {
                 colorMap.put(number.incrementAndGet(), Color.valueOf(resultSet.getString(1)));
             }
         } catch (SQLException e) {
-            Utility.getLogger().warning(e.getMessage());
-            Utility.getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
+            log.warning(e.getMessage());
+            log.warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
             return getColorsByGenderAndCategory(gender, category);
         }
         if (colorMap.isEmpty()) {
-            Utility.getLogger().info("\n-----------------------------\nColors not found in " + category + " for " + gender + "\n-----------------------------\n");
+            log.info("\n-----------------------------\nColors not found in " + category + " for " + gender + "\n-----------------------------\n");
         } else {
             String menu = colorMap.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue()).reduce("", (colors, color) -> colors + "\n" + color);
-            Utility.getLogger().info(menu);
+            log.info(menu);
         }
         return colorMap;
     }
@@ -339,29 +345,29 @@ public class RetailStoreService implements RetailStore, ProductFilter {
     @Override
     public void showOrders() {
         boolean orderSelectFlag = true;
-        Connection connection = Database.getConnection();
+        Connection connection = DBUtil.getConnection();
         while (orderSelectFlag) {
             Map<Integer, Order> orders = getOrders(connection);
             String orderMenu = orders.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue().getOrderId() + "\t" + entry.getValue().getCustomerName()).reduce((allorders, order) -> allorders + "\n" + order).orElse("\n----------\nNo orders currently in your orders list");
-            Utility.getLogger().info(orderMenu);
-            Utility.getLogger().info("\n-----------------------------\nEnter 0 to go back.\n-----------------------------\n");
-            Utility.getLogger().info("\n-----------------------------\nSelect order from the above list\n-----------------------------\n");
-            int orderSelected = Utility.getInt();
+            log.info(orderMenu);
+            log.info("\n-----------------------------\nEnter 0 to go back.\n-----------------------------\n");
+            log.info("\n-----------------------------\nSelect order from the above list\n-----------------------------\n");
+            int orderSelected = InputUtil.validateInputNumber();
             if (orderSelected == 0) {
                 orderSelectFlag = false;
                 break;
             }
             Order order = orders.get(orderSelected);
             if (order == null) {
-                Utility.getLogger().info("\n-----------------------------\nPlease select an order available in the list\n-----------------------------\n");
+                log.info("\n-----------------------------\nPlease select an order available in the list\n-----------------------------\n");
                 showOrders();
             } else {
-                Utility.getLogger().info(order.showOrder());
-                Utility.getLogger().info("\n-----------------------------\nenter 1 to view products \n2 to see orders \nenter any keyword to exit");
-                int chooseProductList = Utility.getInt();
+                log.info(order.showOrder());
+                log.info("\n-----------------------------\nenter 1 to view products \n2 to see orders \nenter any keyword to exit");
+                int chooseProductList = InputUtil.validateInputNumber();
                 switch (chooseProductList) {
                     case 1:
-                        Utility.getLogger().info("\n-----------------------------\n" + order.showProducts() + "\n-----------------------------\n");
+                        log.info("\n-----------------------------\n" + order.showProducts() + "\n-----------------------------\n");
                         break;
                     case 2:
                         continue;
@@ -376,8 +382,7 @@ public class RetailStoreService implements RetailStore, ProductFilter {
         Map<Integer, Order> ordersMenu = new LinkedHashMap<>();
         List<OrderedProduct> orderedProductList;
         AtomicInteger number = new AtomicInteger(0);
-        try {
-            PreparedStatement preparedStatement = connection.prepareStatement("select * from orders order by date desc");
+        try (PreparedStatement preparedStatement = connection.prepareStatement("select * from orders order by date desc");) {
             ResultSet resultSet = preparedStatement.executeQuery();
             while (resultSet.next()) {
                 orderedProductList = new ArrayList<>();
@@ -390,7 +395,7 @@ public class RetailStoreService implements RetailStore, ProductFilter {
                 ordersMenu.put(number.incrementAndGet(), new Order(resultSet.getString(1), resultSet.getDate(4).toLocalDate(), resultSet.getTime(5).toLocalTime(), resultSet.getString(2), resultSet.getString(3), resultSet.getDouble(6), orderedProductList));
             }
         } catch (Exception e) {
-            Utility.getLogger().warning(e.getMessage());
+            log.warning(e.getMessage());
         }
         return ordersMenu;
     }

src/main/java/com/retailstore/ordermanagement/utils/DBUtil.java

@@ -9,14 +9,14 @@ import java.sql.SQLException;
  * This is a final class in which all the configurations of the database are present to
  * establish the connection to the database to the project
  */
-public final class Database {
+public final class DBUtil {
     private static Connection connection;
 
     /**
      * Private constructor that will not
      * allow to create object
      */
-    private Database() {
+    private DBUtil() {
     }
 
     /**

src/main/java/com/retailstore/ordermanagement/utils/InputUtil.java

 package com.retailstore.ordermanagement.utils;
 
-import com.retailstore.ordermanagement.application.OrderManagement;
 import com.retailstore.ordermanagement.constants.Category;
 import com.retailstore.ordermanagement.constants.Color;
 import com.retailstore.ordermanagement.constants.Gender;
 import com.retailstore.ordermanagement.constants.Size;
 import com.retailstore.ordermanagement.model.Order;
 import com.retailstore.ordermanagement.service.RetailStoreService;
+import lombok.extern.java.Log;
 
 import java.util.*;
 import java.util.logging.Logger;
@@ -17,14 +17,15 @@ import java.util.logging.Logger;
  * Class used to import the values of the option given in the console and print accordingly
  * of the required choice chosen
  */
-public class Utility {
+@Log
+public class InputUtil {
     private static final Scanner SCANNER = null;
     private static final Logger LOGGER = null;
 
     /**
      * No argument constructor
      */
-    private Utility() {
+    private InputUtil() {
     }
 
     /**
@@ -38,11 +39,11 @@ public class Utility {
         Category categoryValue;
         String categoryOptions = Arrays.stream(Category.values()).filter(category -> !category.equals(Category.EXIT)).map(category -> "(" + category.getOption() + ")" + category).reduce((categories, category) -> categories + " " + category).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         categoryValue = Arrays.stream(Category.values()).filter(category -> category.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\n+Please enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\n+Please enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
             return getCategory(false, message);
         });
         return categoryValue.equals(Category.EXIT) ? null : categoryValue;
@@ -59,11 +60,11 @@ public class Utility {
         Size sizeValue;
         String categoryOptions = Arrays.stream(Size.values()).filter(size -> !size.equals(Size.EXIT)).map(size -> "(" + size.getOption() + ")" + size).reduce((sizes, size) -> sizes + " " + size).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         sizeValue = Arrays.stream(Size.values()).filter(size -> size.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\nPlease enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\nPlease enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
             return getSize(false, message);
         });
         return sizeValue.equals(Size.EXIT) ? null : sizeValue;
@@ -80,11 +81,11 @@ public class Utility {
         Gender genderValue;
         String genderOptions = Arrays.stream(Gender.values()).filter(gender -> !gender.equals(Gender.EXIT)).map(gender -> "(" + gender.getOption() + ")" + gender).reduce((genders, gender) -> genders + " " + gender).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + genderOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + genderOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         genderValue = Arrays.stream(Gender.values()).filter(gender -> gender.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\nPlease enter valid gender\n------------------------\n" + genderOptions + "\n------------------------\n");
+            log.info("\n------------------------\nPlease enter valid gender\n------------------------\n" + genderOptions + "\n------------------------\n");
             return getGender(false, message);
         });
         return genderValue.equals(Gender.EXIT) ? null : genderValue;
@@ -101,11 +102,11 @@ public class Utility {
         Color colorValue;
         String colorOptions = Arrays.stream(Color.values()).filter(color -> !color.equals(Color.EXIT)).map(color -> "(" + color.getOption() + ")" + color).reduce((categories, category) -> categories + " " + category).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + colorOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + colorOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         colorValue = Arrays.stream(Color.values()).filter(color -> color.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\n+Please enter valid color\n------------------------\n" + colorOptions + "\n------------------------\n");
+            log.info("\n------------------------\n+Please enter valid color\n------------------------\n" + colorOptions + "\n------------------------\n");
             return getColor(false, message);
         });
         return colorValue.equals(Color.EXIT) ? null : colorValue;
@@ -123,7 +124,7 @@ public class Utility {
         double number;
         Scanner scanner = new Scanner(System.in);
         if (flag) {
-            getLogger().info(message);
+            log.info(message);
         }
         try {
             number = scanner.nextDouble();
@@ -132,7 +133,7 @@ public class Utility {
             }
             return number;
         } catch (InputMismatchException e) {
-            getLogger().warning("\n------------------------\nPlease enter valid price\n------------------------\n");
+            log.warning("\n------------------------\nPlease enter valid price\n------------------------\n");
             scanner.reset();
             return validateInputPrice(false, message);
         }
@@ -154,7 +155,7 @@ public class Utility {
             }
             return number;
         } catch (Exception e) {
-            getLogger().warning(e.getMessage() + "\n------------------------\nPlease enter valid number\n------------------------\n");
+            log.warning(e.getMessage() + "\n------------------------\nPlease enter valid number\n------------------------\n");
             scanner.reset();
             return validateInputNumber();
         }
@@ -174,22 +175,14 @@ public class Utility {
             if (phoneNumber == null || phoneNumber.isBlank() || phoneNumber.isEmpty() || phoneNumber.length() != 10) {
                 throw new RuntimeException("Please enter valid number");
             }
+            Long.parseLong(phoneNumber);
         } catch (Exception e) {
-            getLogger().warning("Please enter valid phone number");
+            log.warning("Please enter valid phone number");
             return phoneNumberValidator();
         }
         return phoneNumber;
     }
 
-    /**
-     * This method is used to create a singleton
-     * logger object that is used throughout the application
-     *
-     * @return
-     */
-    public static Logger getLogger() {
-        return LOGGER == null ? Logger.getLogger(OrderManagement.class.getName()) : LOGGER;
-    }
 
     /**
      * This method is used to create a singleton
@@ -201,22 +194,26 @@ public class Utility {
         return SCANNER == null ? new Scanner(System.in) : SCANNER;
     }
 
+    public static String getScannerLine() {
+        return getScanner().nextLine();
+    }
+
     /**
      * This method is used to give a valid number that present in the stock range
      *
      * @return integer according to key type size
      */
     public static Map<Size, Integer> getProductSizes() {
-      Map<Size, Integer> productSizes = new LinkedHashMap<>();
-        getLogger().info("Please enter the available stock for particular sizes \n Number of products with size S");
+        Map<Size, Integer> productSizes = new LinkedHashMap<>();
+        log.info("Please enter the available stock for particular sizes \n Number of products with size S");
         productSizes.put(Size.S, validateInputNumber());
-        getLogger().info("Number of products with size M");
+        log.info("Number of products with size M");
         productSizes.put(Size.M, validateInputNumber());
-        getLogger().info("Number of products with size L");
+        log.info("Number of products with size L");
         productSizes.put(Size.L, validateInputNumber());
-        getLogger().info("Number of products with size XL");
+        log.info("Number of products with size XL");
         productSizes.put(Size.XL, validateInputNumber());
-        getLogger().info("Number of products with size XXL");
+        log.info("Number of products with size XXL");
         productSizes.put(Size.XXL, validateInputNumber());
         return productSizes;
     }
@@ -233,7 +230,7 @@ public class Utility {
      * @return integer according to key type size
      */
     public static Map<Size, Integer> getProductSizes(int s, int m, int l, int xl, int xxl) {
-      Map<Size, Integer> productSizes = new LinkedHashMap<>();
+        Map<Size, Integer> productSizes = new LinkedHashMap<>();
         productSizes.put(Size.S, s);
         productSizes.put(Size.M, m);
         productSizes.put(Size.L, l);

src/test/java/com/retailstore/ordermanagement/service/ProductServiceTest.java

@@ -11,17 +11,20 @@ import org.junit.jupiter.api.Test;
 import org.mockito.Mock;
 
 import java.sql.Connection;
-import java.util.*;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
 import java.util.stream.Collectors;
 
-class ProductFilterTest {
+class ProductServiceTest {
     @Mock
     Connection connection;
-    RetailStoreService service;
+    RetailStoreServiceImpl service;
 
     @BeforeEach
     void createretailsStoreObject() {
-        service = new RetailStoreService();
+        service = new RetailStoreServiceImpl();
     }
 
     @AfterEach
@@ -31,7 +34,7 @@ class ProductFilterTest {
 
     @Test
     void getCategoriesByGenderTest() {
-        Map<Integer, Category> categoryMap = new HashMap<>();
+        Map<Integer, Category> categoryMap = new LinkedHashMap<>();
         categoryMap.put(1, Category.SWEATSHIRTS);
         categoryMap.put(2, Category.T_SHIRTS);
         categoryMap.put(3, Category.SHIRTS);
@@ -57,7 +60,7 @@ class ProductFilterTest {
 
     @Test
     void getColorsByGenderAndCategoryTest() {
-        Map<Integer, Color> colorMap = new HashMap<>();
+        Map<Integer, Color> colorMap = new LinkedHashMap<>();
         colorMap.put(1, Color.BLUE);
         colorMap.put(2, Color.GREY);
         colorMap.put(3, Color.BLACK);
@@ -69,7 +72,7 @@ class ProductFilterTest {
     @Test
     void getOrdersTest() {
         List<Order> orderList = new ArrayList<>();
-        Map<Integer, Order> ordersMap = new HashMap<>();
+        Map<Integer, Order> ordersMap = new LinkedHashMap<>();
         Assertions.assertEquals(ordersMap, service.getOrders(connection));
     }
 }
\ No newline at end of file

src/test/java/com/retailstore/ordermanagement/service/RetailStoreServiceTest.java

@@ -4,83 +4,49 @@ import com.retailstore.ordermanagement.constants.Category;
 import com.retailstore.ordermanagement.constants.Color;
 import com.retailstore.ordermanagement.constants.Gender;
 import com.retailstore.ordermanagement.constants.Size;
-import com.retailstore.ordermanagement.model.Order;
-import com.retailstore.ordermanagement.model.OrderedProduct;
-import com.retailstore.ordermanagement.utils.Utility;
-import org.junit.jupiter.api.AfterEach;
+import com.retailstore.ordermanagement.utils.InputUtil;
 import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.mockito.Spy;
 
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
 import java.sql.Connection;
 import java.time.LocalDate;
 import java.time.LocalTime;
-import java.util.ArrayList;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
+import java.util.Scanner;
 
-class RetailStoreTest {
+class RetailStoreServiceTest {
     @Mock
     Connection connection;
-    RetailStoreService service;
-    @Spy
-    @InjectMocks
-    Utility utility;
-
-    @BeforeEach
-    void createretailsStoreObject() {
-        service = new RetailStoreService();
-    }
-
-    @AfterEach
-    void removeretailsStoreObject() {
-        service = null;
-    }
+    RetailStoreServiceImpl service;
 
     @Test
     void addProducts() {
-        LinkedHashMap<Size, Integer> sizeMap = new LinkedHashMap<>();
+        Scanner scanner = Mockito.mock(Scanner.class);
+        Map<Size, Integer> sizeMap = new LinkedHashMap<>();
         sizeMap.put(Size.S, 2);
         sizeMap.put(Size.M, 2);
         sizeMap.put(Size.L, 2);
         sizeMap.put(Size.XL, 2);
         sizeMap.put(Size.XXL, 2);
-        Mockito.when(utility.productIdGenerator()).thenReturn("TestMethod" + LocalDate.now() + LocalTime.now());
-        Mockito.when(Utility.getScanner().nextLine()).thenReturn("TestProduct");
-        Mockito.when(Utility.getCategory(true, "Test check")).thenReturn(Category.JEANS);
-        Mockito.when(Utility.getColor(true, "Test check")).thenReturn(Color.BLACK);
-        Mockito.when(Utility.getGender(true, "Test check")).thenReturn(Gender.WOMEN);
-        Mockito.when(Utility.getDouble(true, "Test price")).thenReturn(1350.00);
-        Mockito.when(Utility.getProductSizes()).thenReturn(sizeMap);
+        try (MockedStatic<InputUtil> inputUtil = Mockito.mockStatic(InputUtil.class)) {
+
+            inputUtil.when(() -> InputUtil.productIdGenerator()).thenReturn("TestMethod" + LocalDate.now() + LocalTime.now());
+            String input = "Test Input";
+            InputStream in = new ByteArrayInputStream(input.getBytes());
+            System.setIn(in);
+            inputUtil.when(() -> InputUtil.validateInputNumber()).thenReturn(2);
+            inputUtil.when(() -> InputUtil.getCategory(true, "Test check")).thenReturn(Category.JEANS);
+            inputUtil.when(() -> InputUtil.getColor(true, "Test check")).thenReturn(Color.BLACK);
+            inputUtil.when(() -> InputUtil.getGender(true, "Test check")).thenReturn(Gender.WOMEN);
+            inputUtil.when(() -> InputUtil.validateInputPrice(true, "Test price")).thenReturn(1350.00);
+            inputUtil.when(() -> InputUtil.getProductSizes()).thenReturn(sizeMap);
+        }
         Assertions.assertEquals(true, service.addProducts());
     }
-
-    @Test
-    void placeOrders() {
-
-    }
-
-    @Test
-    void showOrdersTest() {
-        Map<Integer, Order> ordersMap = Mockito.mock(LinkedHashMap.class);
-        List<OrderedProduct> orderedProductList = Mockito.mock(ArrayList.class);
-        ordersMap.put(1, new Order("10bc46f3#Order", LocalDate.now(), LocalTime.now(), "Customer", "9633214574", 2500.00, new ArrayList<OrderedProduct>()));
-        Mockito.when(service.getOrders(connection)).thenReturn(ordersMap);
-    }
-
-    @Test
-    void createOrder() {
-        ArrayList<OrderedProduct> orderedProducts = new ArrayList<>();
-        orderedProducts.add(new OrderedProduct("test1", "testname", Category.JEANS, Color.BLACK, 1200.00, Gender.MEN, Size.L, 2));
-//        Mockito.when(getGender(true, "Test check")).thenReturn(Gender.WOMEN);
-    }
-
-    @Test
-    void addProductToCart() {
-    }
 }
\ No newline at end of file