UnknownHostException exception = assertThrows(UnknownHostException.class, () -> {
            nameServiceClient.getNbtByName("NONEXISTENT-FAST-FAIL");
        }, "Should throw UnknownHostException for non-existent NetBIOS name");

        // Verify the exception message indicates name resolution failure
        assertTrue(exception.getMessage().contains("NONEXISTENT") || exception.getMessage().contains("unknown")

        } catch (org.codelibs.core.exception.ResourceNotFoundRuntimeException e) {
            // Expected behavior - method throws exception for non-existent files
            assertTrue(e.getMessage().contains("nonexistent.conf"));
        }

        // Test with multiple names - should also throw exception for non-existent files
        try {

		return true
	}

	for {
		select {
		case err := <-globalHTTPServerErrorCh:
			shutdownLogIf(context.Background(), err)
			exit(stopProcess())
		case osSignal := <-globalOSSignalCh:
			logger.Info("Exiting on signal: %s", strings.ToUpper(osSignal.String()))
			daemon.SdNotify(false, daemon.SdNotifyStopping)
			exit(stopProcess())
		case signal := <-globalServiceSignalCh:
			switch signal {
			case serviceRestart:

followed by <a href="#Instantiations">type arguments</a> if the type is generic.
A type may also be specified using a <i>type literal</i>, which composes a type
from existing types.
</p>

<pre class="ebnf">
Type     = TypeName [ TypeArgs ] | TypeLit | "(" Type ")" .
TypeName = identifier | QualifiedIdent .
TypeArgs = "[" TypeList [ "," ] "]" .
TypeList = Type { "," Type } .

            }
        };

        try {
            emptyEnv.get("non.existent.property");
            fail("Should throw ConfigPropertyNotFoundException");
        } catch (ConfigPropertyNotFoundException e) {
            assertTrue(e.getMessage().contains("non.existent.property"));
        }

        try {
            emptyEnv.is("non.existent.boolean");
            fail("Should throw ConfigPropertyNotFoundException");

    public void test_get_nullProperty() {
        // Test getting non-existent property
        try {
            fessConfig.get("non.existent.property");
            fail("Should throw exception for non-existent property");
        } catch (ConfigPropertyNotFoundException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("non.existent.property"));
        }
    }

        // Test operations on empty service
        assertEquals(0, mockService.getRegistrationCount());
        assertFalse(mockService.hasRegistration("non-existent"));
        assertFalse(mockService.unregisterWitness("non-existent"));
        assertFalse(mockService.processHeartbeat("non-existent", 1));

        // Test registration with null/empty values
        String regId1 = mockService.registerWitness(null, "192.168.1.100", 1);

 * (first-in-first-out). This data structure is logically equivalent to a circular buffer (i.e.,
 * cyclic buffer or ring buffer).
 *
 * <p>An evicting queue must be configured with a maximum size. Each time an element is added to a
 * full queue, the queue automatically removes its head element. This is different from conventional

                directoryCache.remove(directoryPath);
                return null;
            }
        }

        return entry;
    }

    /**
     * Check if directory listing can be cached
     *
     * @param directoryPath directory path
     * @return true if caching is allowed
     */
    public boolean canCacheDirectoryListing(String directoryPath) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.admin.design;

/**
 * Form class for editing design files in the admin interface.
 * This form handles the editing of template and design files used
 * for customizing the search interface appearance and layout.
 */
public class EditForm {

    /**
     * Creates a new EditForm instance.