errInvalidTagValue = Errorf("The TagValue you have provided is invalid")
)

func (tag Tag) String() string {
	return tag.Key + "=" + tag.Value
}

// IsEmpty returns whether this tag is empty or not.
func (tag Tag) IsEmpty() bool {
	return tag.Key == ""
}

// Validate checks this tag.
func (tag Tag) Validate() error {
	if len(tag.Key) == 0 || utf8.RuneCountInString(tag.Key) > 128 {

                        .orElse(false);
        runtime.registerData("editable", editable);
        runtime.registerData("editableClass", editable ? StringUtil.EMPTY : "disabled");
        runtime.registerData("fesenType", fessConfig.getFesenType());
        final String forumLink = systemHelper.getForumLink();
        if (StringUtil.isNotBlank(forumLink)) {

     * restored. This provides a seamless user experience after authentication.
     *
     * @return Optional HtmlResponse containing the redirect to search page with parameters,
     *         or empty if no search parameters were found
     */
    protected OptionalThing<HtmlResponse> redirectToSearchPage() {
        final RequestParameter[] searchParameters = searchHelper.getSearchParameters();

            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {
            String msg = "Cannot register null or empty query collection: name=" + name + " values=" + values;

    void testErrorConditions() {
        // 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

		return err
	}

	if !r.Source.Creds.Empty() {
		if err := r.Source.Creds.Validate(); err != nil {
			return err
		}
	}
	if r.Target.Endpoint == "" && !r.Target.Creds.Empty() {
		return errInvalidArgument
	}

	if r.Source.Endpoint == "" && !r.Source.Creds.Empty() {
		return errInvalidArgument
	}

func NewEndpoint(arg string) (ep Endpoint, e error) {
	// isEmptyPath - check whether given path is not empty.
	isEmptyPath := func(path string) bool {
		return path == "" || path == SlashSeparator || path == `\`
	}

	if isEmptyPath(arg) {
		return ep, fmt.Errorf("empty or root endpoint is not supported")
	}

	var isLocal bool
	var host string
	u, err := url.Parse(arg)

        //    return null; // handled later
        //}
    }

    @Override
    public OptionalThing<String> determineAlias(final Locale locale) {
        return OptionalObject.empty();
    }

                            + " is set and its value is not \"false\". Disable this detection by removing that variable or by setting it to \"false\"";
                }
            });
        }
        return Optional.empty();
    }

                } catch (final IOException e) {
                    throw new IORuntimeException(e);
                }
                return true;
            }, OptionalThing.empty());
            response.flushBuffer();
            if (logger.isDebugEnabled()) {
                logger.debug("Loaded {} documents", count);
            }