ThrowingSupplier_Test

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.juneau.junit.bct;

import static org.junit.jupiter.api.Assertions.*;

import java.util.*;

import org.apache.juneau.*;
import org.junit.jupiter.api.*;

/**
 * Unit tests for the {@link ThrowingSupplier} functional interface.
 *
 * <p>This test class verifies functional interface compliance, exception handling,
 * and integration with the Utils.safe() method.</p>
 */
class ThrowingSupplier_Test extends TestBase {

	// ====================================================================================================
	// Functional Interface Compliance Tests
	// ====================================================================================================

	@Nested
	class A_functionalInterfaceCompliance extends TestBase {

		@SuppressWarnings("cast")
		@Test
		void a01_functionalInterfaceContract() {
			// Verify it's a proper functional interface
			ThrowingSupplier<String> supplier = () -> "test_value";

			assertNotNull(supplier);
			assertTrue(supplier instanceof ThrowingSupplier);
		}

		@Test
		void a02_lambdaExpressionCompatibility() throws Exception {
			// Test lambda expression usage
			ThrowingSupplier<Integer> lambda = () -> 42;

			var result = lambda.get();
			assertEquals(42, result);
		}

		@Test
		void a03_methodReferenceCompatibility() throws Exception {
			// Test method reference usage
			ThrowingSupplier<String> methodRef = SupplierMethods::getValue;

			var result = methodRef.get();
			assertEquals("METHOD_VALUE", result);
		}

		@Test
		void a04_exceptionThrowingCapability() {
			// Test that it can throw checked exceptions
			ThrowingSupplier<String> throwingSupplier = () -> {
				throw new Exception("Test checked exception");
			};

			// Should be able to throw checked exceptions
			assertThrows(Exception.class, throwingSupplier::get);
		}
	}

	// ====================================================================================================
	// Exception Handling Tests
	// ====================================================================================================

	@Nested
	class B_exceptionHandling extends TestBase {

		@Test
		void b01_checkedExceptionHandling() {
			ThrowingSupplier<String> supplier = () -> {
				throw new java.io.IOException("IO error");
			};

			assertThrows(java.io.IOException.class, supplier::get);
		}

		@Test
		void b02_runtimeExceptionHandling() {
			ThrowingSupplier<String> supplier = () -> {
				throw new RuntimeException("Runtime error");
			};

			assertThrows(RuntimeException.class, supplier::get);
		}

		@Test
		void b03_multipleExceptionTypes() {
			ThrowingSupplier<String> ioSupplier = () -> {
				throw new java.io.IOException("IO exception");
			};

			ThrowingSupplier<String> parseSupplier = () -> {
				throw new java.text.ParseException("Parse exception", 0);
			};

			assertThrows(java.io.IOException.class, ioSupplier::get);
			assertThrows(java.text.ParseException.class, parseSupplier::get);
		}

		@Test
		void b04_noExceptionCase() throws Exception {
			ThrowingSupplier<String> normalSupplier = () -> "normal_value";

			var result = normalSupplier.get();
			assertEquals("normal_value", result);
		}
	}

	// ====================================================================================================
	// Integration with Utils.safe() Tests
	// ====================================================================================================

	@Nested
	class C_utilsSafeIntegration extends TestBase {

		@Test
		void c01_safeExecutionWithoutException() {
			ThrowingSupplier<String> supplier = () -> "safe_value";

			var result = Utils.safe(supplier);
			assertEquals("safe_value", result);
		}

		@Test
		void c02_safeExecutionWithCheckedException() {
			ThrowingSupplier<String> supplier = () -> {
				throw new java.io.IOException("Checked exception");
			};

			// Utils.safe should wrap checked exceptions in RuntimeException
			var exception = assertThrows(RuntimeException.class, () -> Utils.safe(supplier));
			assertTrue(exception.getCause() instanceof java.io.IOException);
			assertEquals("Checked exception", exception.getCause().getMessage());
		}

		@Test
		void c03_safeExecutionWithRuntimeException() {
			ThrowingSupplier<String> supplier = () -> {
				throw new RuntimeException("Runtime exception");
			};

			// Utils.safe should re-throw RuntimeExceptions as-is
			var exception = assertThrows(RuntimeException.class, () -> Utils.safe(supplier));
			assertEquals("Runtime exception", exception.getMessage());
			assertNull(exception.getCause()); // Should not be wrapped
		}

		@Test
		void c04_safeExecutionWithNullReturn() {
			ThrowingSupplier<String> supplier = () -> null;

			var result = Utils.safe(supplier);
			assertNull(result);
		}
	}

	// ====================================================================================================
	// Complex Scenario Tests
	// ====================================================================================================

	@Nested
	class D_complexScenarios extends TestBase {

		@Test
		void d01_fileOperationSimulation() {
			// Simulate file reading that might throw IOException
			ThrowingSupplier<String> fileReader = () -> {
				// Simulate file not found
				throw new java.io.FileNotFoundException("File not found");
			};

			var exception = assertThrows(RuntimeException.class, () -> Utils.safe(fileReader));
			assertTrue(exception.getCause() instanceof java.io.FileNotFoundException);
		}

		@Test
		void d02_networkOperationSimulation() {
			// Simulate network operation that might timeout
			ThrowingSupplier<String> networkCall = () -> {
				// Simulate network timeout
				throw new java.net.SocketTimeoutException("Connection timeout");
			};

			var exception = assertThrows(RuntimeException.class, () -> Utils.safe(networkCall));
			assertTrue(exception.getCause() instanceof java.net.SocketTimeoutException);
		}

		@Test
		void d03_databaseOperationSimulation() {
			// Simulate database operation that might throw SQLException
			ThrowingSupplier<List<String>> dbQuery = () -> {
				// Simulate SQL exception
				throw new java.sql.SQLException("Database connection failed");
			};

			var exception = assertThrows(RuntimeException.class, () -> Utils.safe(dbQuery));
			assertTrue(exception.getCause() instanceof java.sql.SQLException);
		}

		@Test
		void d04_successfulComplexOperation() {
			// Simulate successful complex operation
			ThrowingSupplier<Map<String, Object>> complexOperation = () -> {
				var result = new HashMap<String, Object>();
				result.put("status", "success");
				result.put("data", Arrays.asList("item1", "item2", "item3"));
				result.put("timestamp", System.currentTimeMillis());
				return result;
			};

			var result = Utils.safe(complexOperation);
			assertNotNull(result);
			assertEquals("success", result.get("status"));
			assertNotNull(result.get("data"));
			assertNotNull(result.get("timestamp"));
		}
	}

	// ====================================================================================================
	// Performance and Resource Tests
	// ====================================================================================================

	@Nested
	class E_performanceAndResources extends TestBase {

		@Test
		void e01_quickExecution() {
			ThrowingSupplier<String> fastSupplier = () -> "quick_result";

			var start = System.nanoTime();
			var result = Utils.safe(fastSupplier);
			var end = System.nanoTime();

			assertEquals("quick_result", result);
			assertTrue((end - start) < 1_000_000); // Less than 1ms
		}

		@Test
		void e02_multipleExecutions() {
			var counter = new ThrowingSupplier<Integer>() {
				private int count = 0;
				@Override
				public Integer get() {
					return ++count;
				}
			};

			assertEquals(1, Utils.safe(counter));
			assertEquals(2, Utils.safe(counter));
			assertEquals(3, Utils.safe(counter));
		}

		@Test
		void e03_resourceCleanupSimulation() {
			// Simulate resource that needs cleanup
			var resourceClosed = new boolean[]{false};

			ThrowingSupplier<String> resourceUser = () -> {
				try {
					// Simulate resource usage
					return "resource_data";
				} finally {
					// Simulate cleanup
					resourceClosed[0] = true;
				}
			};

			var result = Utils.safe(resourceUser);
			assertEquals("resource_data", result);
			assertTrue(resourceClosed[0], "Resource should be cleaned up");
		}

		@Test
		void e04_exceptionInFinallyBlock() {
			// Test behavior when exception occurs in finally block
			ThrowingSupplier<String> problematicResource = () -> {
				try {
					return "success";
				} finally {
					// This could happen in real resource cleanup
					// but won't affect the result since it's in finally
					System.gc(); // Safe operation for test
				}
			};

			var result = Utils.safe(problematicResource);
			assertEquals("success", result);
		}
	}

	// ====================================================================================================
	// Concurrency Tests
	// ====================================================================================================

	@Nested
	class F_concurrency extends TestBase {

		@Test
		void f01_threadSafeExecution() {
			ThrowingSupplier<String> supplier = () -> "thread_safe_value";

			// Test concurrent execution
			var futures = new ArrayList<java.util.concurrent.CompletableFuture<String>>();
			for (int i = 0; i < 10; i++) {
				futures.add(java.util.concurrent.CompletableFuture.supplyAsync(() -> Utils.safe(supplier)));
			}

			// All should complete successfully
			for (var future : futures) {
				assertEquals("thread_safe_value", future.join());
			}
		}

		@Test
		void f02_concurrentExceptionHandling() {
			ThrowingSupplier<String> throwingSupplier = () -> {
				throw new RuntimeException("Concurrent exception");
			};

			// Test concurrent exception handling
			var futures = new ArrayList<java.util.concurrent.CompletableFuture<RuntimeException>>();
			for (int i = 0; i < 5; i++) {
				futures.add(java.util.concurrent.CompletableFuture.supplyAsync(() -> {
					try {
						Utils.safe(throwingSupplier);
						return null; // Should not reach here
					} catch (RuntimeException e) {
						return e;
					}
				}));
			}

			// All should throw the same exception type
			for (var future : futures) {
				var exception = future.join();
				assertNotNull(exception);
				assertEquals("Concurrent exception", exception.getMessage());
			}
		}
	}

	// ====================================================================================================
	// Generic Type Tests
	// ====================================================================================================

	@Nested
	class G_genericTypes extends TestBase {

		@Test
		void g01_stringTypeSupplier() throws Exception {
			ThrowingSupplier<String> stringSupplier = () -> "string_value";
			assertEquals("string_value", stringSupplier.get());
		}

		@Test
		void g02_integerTypeSupplier() throws Exception {
			ThrowingSupplier<Integer> intSupplier = () -> 42;
			assertEquals(42, intSupplier.get());
		}

		@Test
		void g03_listTypeSupplier() throws Exception {
			ThrowingSupplier<List<String>> listSupplier = () -> Arrays.asList("a", "b", "c");
			var result = listSupplier.get();
			assertEquals(3, result.size());
			assertEquals("a", result.get(0));
		}

		@Test
		void g04_mapTypeSupplier() throws Exception {
			ThrowingSupplier<Map<String, Integer>> mapSupplier = () -> {
				var map = new HashMap<String, Integer>();
				map.put("key1", 1);
				map.put("key2", 2);
				return map;
			};

			var result = mapSupplier.get();
			assertEquals(2, result.size());
			assertEquals(1, result.get("key1"));
		}

		@Test
		void g05_customObjectTypeSupplier() throws Exception {
			ThrowingSupplier<TestResult> objectSupplier = () -> new TestResult("success", 100);

			var result = objectSupplier.get();
			assertEquals("success", result.status);
			assertEquals(100, result.value);
		}
	}

	// ====================================================================================================
	// Helper Classes and Methods
	// ====================================================================================================

	static class SupplierMethods {
		static String getValue() {
			return "METHOD_VALUE";
		}

		static String getValueWithException() throws Exception {
			throw new Exception("Method exception");
		}
	}

	static class TestResult {
		final String status;
		final int value;

		TestResult(String status, int value) {
			this.status = status;
			this.value = value;
		}
	}
}