more tests for coverage

Author: itsamekadio

implicitlock/src/main/java/com/iluwatar/BusinessTransaction.java

@@ -1,11 +1,15 @@
 package com.iluwatar;
 
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 /**
  * BusinessTransaction class handles the logic of processing customer transactions.
  * It works with the Framework to acquire and release locks for resources.
  */
 public class BusinessTransaction {
 
+  private static final Logger logger = Logger.getLogger(BusinessTransaction.class.getName());
   private final Framework framework;
 
   /**
@@ -24,10 +28,11 @@ public BusinessTransaction(Framework framework) {
    * @param resource the resource to be locked during the transaction
    * @param customerId the ID of the customer being processed
    * @param customerData the data related to the customer being processed
+   * @return true if the transaction was processed successfully, false otherwise
    */
-  public void processCustomer(Resource resource, String customerId, String customerData) {
-    // Print a message indicating which customer is being processed
-    System.out.println("Processing customer " + customerId + " with data: " + customerData);
+  public boolean processCustomer(Resource resource, String customerId, String customerData) {
+    // Log a message indicating which customer is being processed
+    logger.log(Level.INFO, "Processing customer {0} with data: {1}", new Object[]{customerId, customerData});
 
     // Try to acquire the lock for the resource
     if (framework.tryLockResource(resource)) {
@@ -36,11 +41,18 @@ public void processCustomer(Resource resource, String customerId, String custome
         Thread.sleep(500);
       } catch (InterruptedException e) {
         Thread.currentThread().interrupt();  // Handle interruption
+        return false;  // Return false if the thread was interrupted
       }
+
       // Release the lock after processing is done
       framework.notifyReleaseLock(resource);
+
+      // Log success and return true to indicate the transaction was completed
+      logger.log(Level.INFO, "Customer {0} processed successfully.", customerId);
+      return true;
     } else {
-      System.out.println("Failed to acquire lock for resource: " + resource.getId());
+      logger.log(Level.WARNING, "Failed to acquire lock for resource: {0}", resource.getId());
+      return false;  // Return false if the lock was not acquired
     }
   }
 }

implicitlock/src/test/java/com/iluwatar/implicitlock/BusinessTransactionTest.java

@@ -0,0 +1,51 @@
+package com.iluwatar.implicitlock;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import com.iluwatar.Framework;
+import com.iluwatar.LockManager;
+import com.iluwatar.Resource;
+import com.iluwatar.BusinessTransaction;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BusinessTransactionTest {
+
+  private LockManager lockManager;
+  private Framework framework;
+  private Resource resource1;
+  private BusinessTransaction transaction;
+
+  @BeforeEach
+  void setUp() {
+    lockManager = new LockManager();
+    framework = new Framework(lockManager);
+    transaction = new BusinessTransaction(framework);
+    resource1 = new Resource("Resource1");
+  }
+
+  @Test
+  void verifyProcessCustomerSuccess() {
+    // Process a customer transaction and assert it returns true (indicating success)
+    boolean result = transaction.processCustomer(resource1, "456", "Customer data for 456");
+    assertTrue(result, "The transaction should be processed successfully and return true");
+  }
+  @Test
+  void verifyProcessCustomerWithInterruption() {
+    // Simulate an interrupted transaction and ensure it returns false
+    Thread transactionThread = new Thread(() -> {
+      boolean result = transaction.processCustomer(resource1, "456", "Customer data for 456");
+      assertFalse(result, "The transaction should return false if interrupted");
+    });
+
+    // Start and interrupt the transaction thread
+    transactionThread.start();
+    transactionThread.interrupt();
+
+    try {
+      transactionThread.join();  // Wait for thread to finish
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+    }
+  }
+}

implicitlock/src/test/java/com/iluwatar/implicitlock/ImplicitlockTest.java

@@ -64,4 +64,5 @@ void verifyResourceLockedByDifferentThreads() throws InterruptedException {
     thread2.start();
     thread2.join();
   }
-}
+
+}