assertTrue(str.contains("mid=1"));
    }

    @Test
    void testToStringUnknownCommand() {
        smb.command = (byte) 0xFF; // Unknown command
        smb.errorCode = 0;
        smb.mid = 1;
        String str = smb.toString();
        assertTrue(str.contains("command=UNKNOWN"));
    }

            return convertFuzzyQuery(context, fuzzyQuery, boost);
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a Lucene FuzzyQuery into an OpenSearch fuzzy query builder.

        REMOVE_SERVICE=true
        REMOVE_USER_AND_GROUP=true
    ;;
    1)
        # If $1=1 this is an upgrade
        IS_UPGRADE=true
    ;;

    *)
        echo "post remove script called with unknown argument \`$1'" >&2
        exit 1
    ;;
esac

# Sets the default values for fess variables used in this script
FESS_USER="${packaging.fess.user}"
FESS_GROUP="${packaging.fess.group}"

     * Context mismatch fault code
     */
    int DCERPC_FAULT_CONTEXT_MISMATCH = 0x1C00001A;
    /**
     * Operation range error fault code
     */
    int DCERPC_FAULT_OP_RNG_ERROR = 0x1C010002;
    /**
     * Unknown interface fault code
     */
    int DCERPC_FAULT_UNK_IF = 0x1C010003;
    /**
     * Protocol error fault code
     */
    int DCERPC_FAULT_PROTO_ERROR = 0x1c01000b;

    /**

                if (!warnings.contains(req.getMessage())) {
                    warnings.add(req.getMessage());
                }
                break;
            default:
                throw new IllegalArgumentException("Unknown severity: " + req.getSeverity());
        }
    }

        assertEquals("auth_error", LlmException.ERROR_AUTH);
        assertEquals("service_unavailable", LlmException.ERROR_SERVICE_UNAVAILABLE);
        assertEquals("unknown", LlmException.ERROR_UNKNOWN);
    }

    @Test
    public void test_getErrorCodeWithServiceUnavailable() {

        assertEquals(specificHandler, corsHandlerFactory.get(specificOrigin));

        // Execute & Verify - unknown origin should return wildcard handler
        assertEquals(wildcardHandler, corsHandlerFactory.get("https://unknown.com"));
    }

    @Test
    public void test_get_nonExistentOriginWithoutWildcard() {
        // Setup
        String origin = "https://example.com";

            return convertTermRangeQuery(context, termRangeQuery, boost);
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a TermRangeQuery to a QueryBuilder with the given boost value.
     * Handles both search fields and default field queries with proper range semantics.

     * @param realm Server realm
     * @param principalName Server principal name
     * @param encType Encryption type
     * @param encryptedData Encrypted data
     * @param unknownTag Optional unknown tag number to test error handling
     * @return A byte array representing the ticket
     * @throws IOException on encoding error
     */

    app = FastAPI()

    def extract_request_info(request: Request) -> dict:
        return {
            "path": request.url.path,
            "user_agent": request.headers.get("user-agent", "unknown"),
        }

    @app.get("/")
    def endpoint(
        info: Annotated[dict, Depends(extract_request_info)],
    ):
        return info

    client = TestClient(app)