"number_of_replicas": 0,
      "auto_expand_replicas": "0-1"
    },
    "analysis": {
      "analyzer": {
        "standard_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "cjk_width",
            "asciifolding",
            "lowercase",
            "stop",
            "stemmer"
          ]
        }
      }
    }
  }

      "number_of_replicas": 0,
      "auto_expand_replicas": "0-1"
    },
    "analysis": {
      "analyzer": {
        "standard_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "cjk_width",
            "asciifolding",
            "lowercase",
            "stop",
            "stemmer"
          ]
        }
      }
    }
  }

    /**
     * Test urlFilter getter and setter
     */
    public void test_urlFilter() {
        assertNull(crawlerContext.getUrlFilter());

        TestUrlFilter filter = new TestUrlFilter();
        crawlerContext.setUrlFilter(filter);
        assertSame(filter, crawlerContext.getUrlFilter());

        crawlerContext.setUrlFilter(null);
        assertNull(crawlerContext.getUrlFilter());
    }

    /**

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;

/**
 * Artifact collector - takes a set of original artifacts and resolves the best versions to use
 * along with their metadata. No artifacts are downloaded.
 */
@Deprecated

     */
    protected void addFessConfigProperties(final List<String> cmdList) {
        System.getProperties()
                .keySet()
                .stream()
                .filter(k -> k != null && k.toString().startsWith(Constants.FESS_CONFIG_PREFIX))
                .forEach(k -> addSystemProperty(cmdList, k.toString(), null, null));
    }

    /**

        Field[] fields = SecurityInfo.class.getDeclaredFields();
        long constantCount = Arrays.stream(fields)
                .filter(f -> f.getType() == int.class)
                .filter(f -> Modifier.isStatic(f.getModifiers()))
                .filter(f -> Modifier.isFinal(f.getModifiers()))
                .count();

        assertEquals(8, constantCount, "Should have exactly 8 constant fields");
    }

    }

    /**
     * Gets the notification filter flags that specify which changes to monitor
     * @return the notification filter flags
     */
    public int getNotificationFilter() {
        return notificationFilter;
    }

    /**
     * Sets the notification filter flags that specify which changes to monitor
     * @param notificationFilter the notification filter flags
     */

    void testEquals() {
        AndArtifactFilter filter1 = new AndArtifactFilter();

        AndArtifactFilter filter2 = new AndArtifactFilter(Arrays.asList(newSubFilter()));

        assertFalse(filter1.equals(null));
        assertTrue(filter1.equals(filter1));
        assertEquals(filter1.hashCode(), filter1.hashCode());

        assertFalse(filter1.equals(filter2));
        assertFalse(filter2.equals(filter1));
    }

                .filter(StringUtil::isNotBlank)
                .distinct()
                .collect(Collectors.joining("\n")));
        body.virtualHosts = stream(entity.getVirtualHosts())
                .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().map(String::trim).collect(Collectors.joining("\n")));
        return body;
    }

        if (StringUtil.isNotBlank(value)) {
            split(value, ",").of(stream -> stream.forEach(list::add));
        }
        return list.stream().filter(StringUtil::isNotBlank).map(String::trim).toArray(n -> new String[n]);
    }

    /**
     * Gets the default roles as an array.
     * @return The default roles as an array.
     */