)

// prepareUpdateMessage - prepares the update message, only if a
// newer version is available.
func prepareUpdateMessage(downloadURL string, older time.Duration) string {
	if downloadURL == "" || older <= 0 {
		return ""
	}

	// Compute friendly duration string to indicate time
	// difference between newer and current release.
	t := time.Time{}

            @Override
            public String getRoleSearchUserPrefix() {
                return fessConfig.getRoleSearchUserPrefix();
            }

            @Override
            public String getRoleSearchGroupPrefix() {
                return fessConfig.getRoleSearchGroupPrefix();
            }

            @Override
            public String getRoleSearchRolePrefix() {
                return "";

        SetTestSuiteBuilder.using(
                new TestStringSetGenerator() {
                  @Override
                  protected Set<String> create(String[] elements) {
                    return new StandardImplForwardingSet<>(Sets.newLinkedHashSet(asList(elements)));
                  }
                })
            .named("ForwardingSet[LinkedHashSet] with standard implementations")
            .withFeatures(

        private int flags;
        private int proximity;
        private int pathOffset;
        private int altPathOffset;
        private int nodeOffset;
        private String altPath;

        int ttl;
        String path = null;
        String node = null;

        int readWireFormat( byte[] buffer, int bufferIndex, int len ) {
            int start = bufferIndex;

            version = readInt2( buffer, bufferIndex );

        return true;
    }

    public void test_initializeClientFactory() {
        final Map<String, String> systemPropMap = new HashMap<>();
        FessProp.propMap.clear();
        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public String getSystemProperty(final String key, final String defaultValue) {
                return systemPropMap.getOrDefault(key, defaultValue);
            }

		Description:          m.Description,
		Value:                m.Value,
		HistogramBucketLabel: m.HistogramBucketLabel,
		StaticLabels:         make(map[string]string, len(m.StaticLabels)),
		VariableLabels:       make(map[string]string, len(m.VariableLabels)),
		Histogram:            make(map[string]uint64, len(m.Histogram)),
	}
	for k, v := range m.StaticLabels {
		metric.StaticLabels[k] = v
	}
	for k, v := range m.VariableLabels {

		t.Skip()
	}

	nonLoopBackIP := getNonLoopBackIP(t)

	testCases := []struct {
		serverAddrs []string
	}{
		{[]string{"localhost:0"}},
		{[]string{nonLoopBackIP + ":0"}},
		{[]string{"127.0.0.1:0", nonLoopBackIP + ":0"}},
		{[]string{"localhost:0"}},
		{[]string{nonLoopBackIP + ":0"}},
		{[]string{"127.0.0.1:0", nonLoopBackIP + ":0"}},
	}

nextTest:
	for i, testCase := range testCases {

    DecodingException(@Nullable String message) {
      super(message);
    }
  }

  /** Encodes the specified byte array, and returns the encoded {@code String}. */
  public String encode(byte[] bytes) {
    return encode(bytes, 0, bytes.length);
  }

  /**
   * Encodes the specified range of the specified byte array, and returns the encoded {@code
   * String}.
   */

    /** createdBy */
    protected String createdBy;

    /** createdTime */
    protected Long createdTime;

    /** processType */
    protected String processType;

    /** regex */
    protected String regex;

    /** replacement */
    protected String replacement;

    /** sortOrder */
    protected Integer sortOrder;

    /** updatedBy */

                    "properties": {
                        "username": {"title": "Username", "type": "string"},
                        "password": {"title": "Password", "type": "string"},
                        "email": {
                            "title": "Email",
                            "type": "string",
                            "format": "email",
                        },