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

    /**
     * Converts a TermQuery to a QueryBuilder with the given boost value.
     *
     * @param context the query context

    assertThat(httpUrl.toString())
      .isEqualTo("http://username:password@host/path?query#fragment")
  }

  @Test
  fun fromJavaNetUrlUnsupportedScheme() {
    // java.net.MalformedURLException: unknown protocol: mailto
    platform.assumeNotAndroid()

    // Accessing an URL protocol that was not enabled. The URL protocol mailto is not tested and

            if (matches) {
                return new LicenseInfo(matcher.getIdentifier(), matcher.spdxLicense, matcher.sourceRedistributionRequired);
            }
        }

        throw new IllegalStateException("Unknown license for license file: " + licenseFile);
    }

    public static class LicenseInfo {
        private final String identifier;
        private final boolean spdxLicense;

                String projectName = getParameters().getProjectBuildDirs().get().get(dependencyFile);
                if (projectName == null) {
                    throw new IllegalStateException("Build directory unknown to gradle: " + dependencyFile);
                }
                return "project " + projectName;
            }
            return dependencyFile.getName(); // just the jar filename
        }
    }

						invalid_response: '<la:message key="labels.chat_error_invalid_response" />',
						connection_error: '<la:message key="labels.chat_error_connection" />',
						unknown: '<la:message key="labels.chat_error" />'
					}
				}
			});
		});
	</script>
</body>

	pc, filename, lineNum, ok := runtime.Caller(n)
	if ok {
		filename = pathutil.Base(filename)
		funcName = strings.TrimPrefix(runtime.FuncForPC(pc).Name(),
			"github.com/minio/minio/cmd.")
	} else {
		filename = "<unknown>"
		lineNum = 0
	}

	return fmt.Sprintf("[%s:%d:%s()]", filename, lineNum, funcName)

			t.Fatal(failTestStr(anonTestStr, "error response object name differs from expected value"))
		}
	}

	// test for unknown auth case.
	anonReq.Body = readerTwo
	// Setting the `Authorization` header to a random value so that the signature falls into unknown auth case.
	anonReq.Header.Set("Authorization", "nothingElse")
	// initialize new response recorder.
	rec = httptest.NewRecorder()

                    } else if ("file".equalsIgnoreCase(protocolType)) {
                        addFileProtocol(protocol);
                    } else {
                        logger.warn("Unknown protocol: protocol={}", protocol);
                    }
                }
            } catch (final ClassNotFoundRuntimeException e) {
                logger.debug("{}.{}.Handler does not exist.", basePackage, protocol, e);

            configProps.put(WAGON_TRANSPORTER_PRIORITY_KEY, RESOLVER_MAX_PRIORITY);
        } else if (!MAVEN_RESOLVER_TRANSPORT_AUTO.equals(transport)) {
            throw new IllegalArgumentException("Unknown resolver transport '" + transport
                    + "'. Supported transports are: " + MAVEN_RESOLVER_TRANSPORT_WAGON + ", "
                    + MAVEN_RESOLVER_TRANSPORT_APACHE + ", " + MAVEN_RESOLVER_TRANSPORT_JDK + ", "

        case SMB_COM_CREATE_DIRECTORY -> "SMB_COM_CREATE_DIRECTORY";
        case SMB_COM_NT_TRANSACT -> "SMB_COM_NT_TRANSACT";
        case SMB_COM_NT_TRANSACT_SECONDARY -> "SMB_COM_NT_TRANSACT_SECONDARY";
        default -> "UNKNOWN";
        };
        final String str = errorCode == 0 ? "0" : SmbException.getMessageByCode(errorCode);