System.getProperties()
                        .entrySet()
                        .stream()
                        .forEach(e -> logger.debug("Property: {}={}", e.getKey(),
                                SystemUtil.maskSensitiveValue(String.valueOf(e.getKey()), String.valueOf(e.getValue()))));
                System.getenv()
                        .entrySet()

     * domain, username, and password. Parameters that are {@code null}
     * will be substituted with {@code jcifs.smb.client.domain},
     * {@code jcifs.smb.client.username}, {@code jcifs.smb.client.password}
     * property values.
     *
     * @param tc
     *            context to use
     * @param domain the authentication domain
     * @param username the username to authenticate with

        // ## Act & Assert ##
        assertTrue(Curl.tmpDir.exists());
    }

    @Test
    public void test_TmpDirMatchesSystemProperty() {
        // ## Test that tmpDir matches system property ##

        // ## Act ##
        final String systemTmpDir = System.getProperty("java.io.tmpdir");
        final String curlTmpDir = Curl.tmpDir.getAbsolutePath();

        // ## Assert ##

## ✨ Features

### Core Utilities
- **Bean Manipulation** (`org.codelibs.core.beans`) - JavaBeans metadata handling, property access, and object conversion with comprehensive `BeanDesc` system
- **Type Conversion** (`org.codelibs.core.convert`) - Comprehensive utilities for converting between Java types with null-safe operations and support for all primitive types

    Random r = new Random(0L);
    for (int i = 0; i < 1000000; i++) {
      int dividend = r.nextInt();
      int divisor = r.nextInt();
      // Test that the Euclidean property is preserved:
      assertThat(
              dividend
                  - (divisor * UnsignedInts.divide(dividend, divisor)
                      + UnsignedInts.remainder(dividend, divisor)))
          .isEqualTo(0);

Each connection has its own lock. The connections in the pool are all in a `ConcurrentLinkedQueue`. Due to data races, iterators of this queue may return removed connections. Callers must check the connection's `noNewExchanges` property before using connections from the pool.

The connection lock is never held while doing I/O (even closing a socket) to prevent contention.

            assertEquals(0x20000000, ServerMessageBlock2.SMB2_FLAGS_REPLAY_OPERATION);
        }
    }

    @Nested
    @DisplayName("Basic Property Tests")
    class BasicPropertyTests {

        @Test
        @DisplayName("Should get and set command")
        void testCommandProperty() {
            assertEquals(0, testMessage.getCommand());

    }

    @Test
    public void test_getThumbnailUrl() throws Exception {
        String data = "<meta property=\"og:image\" content=\"http://example/foo.jpg\" />";
        String expected = "http://example/foo.jpg";
        assertGetThumbnailUrl(data, expected);

        data = "<meta property=\"og:image\" content=\"://example/foo.jpg\" />";
        expected = "http://example/foo.jpg";

            }
        }
        return OptionalEntity.empty();
    }

    /**
     * Gets the path to configuration files. In Docker environments, checks /opt/fess first,
     * then falls back to system property FESS_CONF_PATH, and finally to WEB-INF/conf.
     *
     * @param names the path components to append to the configuration directory
     * @return the Path object pointing to the configuration file or directory
     */

                    Object value = entry.getValue();

                    // Handle nested properties
                    if (key.contains(".")) {
                        // Simple nested property handling for testing
                        result = result.replace("${" + key + "}", String.valueOf(value));
                    } else if (value instanceof TestUser) {
                        // Handle TestUser object