@Test
public void testComplexType() {
    AtomicReference<ComplexType> ref = new AtomicReference<>(null);
    Setting<ComplexType> setting = new Setting<>("foo.bar", (s) -> "", (s) -> new ComplexType(s),
        Property.Dynamic, Property.NodeScope);
    assertFalse(setting.isGroupSetting());
    ref.set(setting.get(Settings.EMPTY));
    ComplexType type = ref.get();
    ClusterSettings.SettingUpdater<ComplexType> settingUpdater = setting.newUpdater(ref::set, logger);
    assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY));
    assertSame("no update - type has not changed", type, ref.get());

    // change from default
    assertTrue(settingUpdater.apply(Settings.builder().put("foo.bar", "2").build(), Settings.EMPTY));
    assertNotSame("update - type has changed", type, ref.get());
    assertEquals("2", ref.get().foo);


    // change back to default...
    assertTrue(settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "2").build()));
    assertNotSame("update - type has changed", type, ref.get());
    assertEquals("", ref.get().foo);
}
 

@Test
public void testListSettingsDeprecated() {
    final Setting<List<String>> deprecatedListSetting =
            Setting.listSetting(
                    "foo.deprecated",
                    Collections.singletonList("foo.deprecated"),
                    Function.identity(),
                    Property.Deprecated,
                    Property.NodeScope);
    final Setting<List<String>> nonDeprecatedListSetting =
            Setting.listSetting(
                    "foo.non_deprecated", Collections.singletonList("foo.non_deprecated"), Function.identity(), Property.NodeScope);
    final Settings settings = Settings.builder()
            .put("foo.deprecated", "foo.deprecated1,foo.deprecated2")
            .put("foo.deprecated", "foo.non_deprecated1,foo.non_deprecated2")
            .build();
    deprecatedListSetting.get(settings);
    nonDeprecatedListSetting.get(settings);
    assertSettingDeprecationsAndWarnings(new Setting[]{deprecatedListSetting});
}
 

@Test
public void testDynamicKeySetting() {
    Setting<Boolean> setting = Setting.prefixKeySetting("foo.", (key) -> Setting.boolSetting(key, false, Property.NodeScope));
    assertTrue(setting.hasComplexMatcher());
    assertTrue(setting.match("foo.bar"));
    assertFalse(setting.match("foo"));
    Setting<Boolean> concreteSetting = setting.getConcreteSetting("foo.bar");
    assertTrue(concreteSetting.get(Settings.builder().put("foo.bar", "true").build()));
    assertFalse(concreteSetting.get(Settings.builder().put("foo.baz", "true").build()));

    try {
        setting.getConcreteSetting("foo");
        fail();
    } catch (IllegalArgumentException ex) {
        assertEquals("key [foo] must match [foo.] but didn't.", ex.getMessage());
    }
}
 

@Test
public void testAffixSettingNamespaces() {
    Setting.AffixSetting<Boolean> setting =
        Setting.affixKeySetting("foo.", "enable", (key) -> Setting.boolSetting(key, false, Property.NodeScope));
    Settings build = Settings.builder()
        .put("foo.bar.enable", "true")
        .put("foo.baz.enable", "true")
        .put("foo.boom.enable", "true")
        .put("something.else", "true")
        .build();
    Set<String> namespaces = setting.getNamespaces(build);
    assertEquals(3, namespaces.size());
    assertTrue(namespaces.contains("bar"));
    assertTrue(namespaces.contains("baz"));
    assertTrue(namespaces.contains("boom"));
}
 

@Test
public void testAffixAsMap() {
    Setting.AffixSetting<String> setting = Setting.prefixKeySetting("foo.bar.", key ->
        Setting.simpleString(key, Property.NodeScope));
    Settings build = Settings.builder().put("foo.bar.baz", 2).put("foo.bar.foobar", 3).build();
    Map<String, String> asMap = setting.getAsMap(build);
    assertEquals(2, asMap.size());
    assertEquals("2", asMap.get("baz"));
    assertEquals("3", asMap.get("foobar"));

    setting = Setting.prefixKeySetting("foo.bar.", key ->
        Setting.simpleString(key, Property.NodeScope));
    build = Settings.builder().put("foo.bar.baz", 2).put("foo.bar.foobar", 3).put("foo.bar.baz.deep", 45).build();
    asMap = setting.getAsMap(build);
    assertEquals(3, asMap.size());
    assertEquals("2", asMap.get("baz"));
    assertEquals("3", asMap.get("foobar"));
    assertEquals("45", asMap.get("baz.deep"));
}
 

@Test
public void testGetAllConcreteSettings() {
    Setting.AffixSetting<List<String>> listAffixSetting = Setting.affixKeySetting("foo.", "bar",
        (key) -> Setting.listSetting(key, Collections.emptyList(), Function.identity(), Property.NodeScope));

    Settings settings = Settings.builder()
        .putList("foo.1.bar", "1", "2")
        .putList("foo.2.bar", "3", "4", "5")
        .putList("foo.bar", "6")
        .putList("some.other", "6")
        .putList("foo.3.bar", "6")
        .build();
    Stream<Setting<List<String>>> allConcreteSettings = listAffixSetting.getAllConcreteSettings(settings);
    Map<String, List<String>> collect = allConcreteSettings.collect(Collectors.toMap(Setting::getKey, (s) -> s.get(settings)));
    assertEquals(3, collect.size());
    assertEquals(Arrays.asList("1", "2"), collect.get("foo.1.bar"));
    assertEquals(Arrays.asList("3", "4", "5"), collect.get("foo.2.bar"));
    assertEquals(Arrays.asList("6"), collect.get("foo.3.bar"));
}
 

/**
 * Only one single scope can be added to any setting
 */
@Test
public void testMutuallyExclusiveScopes() {
    // Those should pass
    Setting<String> setting = Setting.simpleString("foo.bar", Property.NodeScope);
    assertThat(setting.hasNodeScope(), is(true));
    assertThat(setting.hasIndexScope(), is(false));
    setting = Setting.simpleString("foo.bar", Property.IndexScope);
    assertThat(setting.hasIndexScope(), is(true));
    assertThat(setting.hasNodeScope(), is(false));

    // We accept settings with no scope but they will be rejected when we register with SettingsModule.registerSetting
    setting = Setting.simpleString("foo.bar");
    assertThat(setting.hasIndexScope(), is(false));
    assertThat(setting.hasNodeScope(), is(false));

    // We accept settings with multiple scopes but they will be rejected when we register with SettingsModule.registerSetting
    setting = Setting.simpleString("foo.bar", Property.IndexScope, Property.NodeScope);
    assertThat(setting.hasIndexScope(), is(true));
    assertThat(setting.hasNodeScope(), is(true));
}
 

@Test
public void testExistsWithFallback() {
    final int count = randomIntBetween(1, 16);
    Setting<String> current = Setting.simpleString("fallback0", Property.NodeScope);
    for (int i = 1; i < count; i++) {
        final Setting<String> next =
                new Setting<>(new Setting.SimpleKey("fallback" + i), current, Function.identity(), Property.NodeScope);
        current = next;
    }
    final Setting<String> fooSetting = new Setting<>(new Setting.SimpleKey("foo"), current, Function.identity(), Property.NodeScope);
    assertFalse(fooSetting.exists(Settings.EMPTY));
    if (randomBoolean()) {
        assertTrue(fooSetting.exists(Settings.builder().put("foo", "bar").build()));
    } else {
        final String setting = "fallback" + randomIntBetween(0, count - 1);
        assertFalse(fooSetting.exists(Settings.builder().put(setting, "bar").build()));
        assertTrue(fooSetting.existsOrFallbackExists(Settings.builder().put(setting, "bar").build()));
    }
}
 

@Test
public void testDependentSettings() {
    Setting.AffixSetting<String> stringSetting = Setting.affixKeySetting("foo.", "name",
        (k) -> Setting.simpleString(k, Property.Dynamic, Property.NodeScope));
    Setting.AffixSetting<Integer> intSetting = Setting.affixKeySetting("foo.", "bar",
        (k) ->  Setting.intSetting(k, 1, Property.Dynamic, Property.NodeScope), stringSetting);

    AbstractScopedSettings service = new ClusterSettings(Settings.EMPTY,new HashSet<>(Arrays.asList(intSetting, stringSetting)));

    IllegalArgumentException iae = expectThrows(IllegalArgumentException.class,
        () -> service.validate(Settings.builder().put("foo.test.bar", 7).build(), true));
    assertEquals("missing required setting [foo.test.name] for setting [foo.test.bar]", iae.getMessage());

    service.validate(Settings.builder()
        .put("foo.test.name", "test")
        .put("foo.test.bar", 7)
        .build(), true);

    service.validate(Settings.builder().put("foo.test.bar", 7).build(), false);
}
 

@Test
public void testIsFinal() {
    ClusterSettings settings =
        new ClusterSettings(Settings.EMPTY,
            new HashSet<>(Arrays.asList(Setting.intSetting("foo.int", 1, Property.Final, Property.NodeScope),
                Setting.groupSetting("foo.group.",  Property.Final, Property.NodeScope),
                Setting.groupSetting("foo.list.",  Property.Final, Property.NodeScope),
                Setting.intSetting("foo.int.baz", 1, Property.NodeScope))));

    assertFalse(settings.isFinalSetting("foo.int.baz"));
    assertTrue(settings.isFinalSetting("foo.int"));

    assertFalse(settings.isFinalSetting("foo.list"));
    assertTrue(settings.isFinalSetting("foo.list.0.key"));
    assertTrue(settings.isFinalSetting("foo.list.key"));

    assertFalse(settings.isFinalSetting("foo.group"));
    assertTrue(settings.isFinalSetting("foo.group.key"));
}
 

@Test
public void testOverlappingComplexMatchSettings() {
    Set<Setting<?>> settings = new LinkedHashSet<>(2);
    final boolean groupFirst = randomBoolean();
    final Setting<?> groupSetting = Setting.groupSetting("foo.", Property.NodeScope);
    final Setting<?> listSetting =
        Setting.listSetting("foo.bar", Collections.emptyList(), Function.identity(), Property.NodeScope);
    settings.add(groupFirst ? groupSetting : listSetting);
    settings.add(groupFirst ? listSetting : groupSetting);

    try {
        new ClusterSettings(Settings.EMPTY, settings);
        fail("an exception should have been thrown because settings overlap");
    } catch (IllegalArgumentException e) {
        if (groupFirst) {
            assertEquals("complex setting key: [foo.bar] overlaps existing setting key: [foo.]", e.getMessage());
        } else {
            assertEquals("complex setting key: [foo.] overlaps existing setting key: [foo.bar]", e.getMessage());
        }
    }
}
 

@Override
public List<Setting<?>> getSettings() {
    List<Setting<?>> settings = sgPlugin.getSettings();
    settings.add(Setting.intSetting(OPENSHIFT_CONTEXT_CACHE_MAXSIZE, DEFAULT_OPENSHIFT_CONTEXT_CACHE_MAXSIZE, Property.NodeScope));
    settings.add(Setting.longSetting(OPENSHIFT_CONTEXT_CACHE_EXPIRE_SECONDS, DEFAULT_OPENSHIFT_CONTEXT_CACHE_EXPIRE_SECONDS, 0, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_ES_KIBANA_SEED_MAPPINGS_APP, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_ES_KIBANA_SEED_MAPPINGS_OPERATIONS, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_ES_KIBANA_SEED_MAPPINGS_EMPTY, Property.NodeScope));
    settings.add(Setting.boolSetting(OPENSHIFT_CONFIG_COMMON_DATA_MODEL, true, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_CONFIG_PROJECT_INDEX_PREFIX, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_CONFIG_TIME_FIELD_NAME, Property.NodeScope));
    settings.add(Setting.simpleString(SG_CLIENT_KS_PATH, Property.NodeScope));
    settings.add(Setting.simpleString(SG_CLIENT_TS_PATH, Property.NodeScope));
    settings.add(Setting.boolSetting(OPENSHIFT_CONFIG_OPS_ALLOW_CLUSTER_READER, false, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_KIBANA_INDEX_MODE, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_ACL_ROLE_STRATEGY, Property.NodeScope));
    settings.add(Setting.listSetting(OPENSHIFT_KIBANA_OPS_INDEX_PATTERNS, Arrays.asList(DEFAULT_KIBANA_OPS_INDEX_PATTERNS),
            Function.identity(), Property.NodeScope, Property.Dynamic));
    settings.add(Setting.simpleString(OPENSHIFT_ACL_EXPIRE_IN_MILLIS, Property.NodeScope));
    settings.add(Setting.simpleString(KIBANA_CONFIG_INDEX_NAME, Property.NodeScope));
    settings.add(Setting.simpleString(KIBANA_CONFIG_VERSION, Property.NodeScope));
    settings.add(Setting.simpleString(KIBANA_VERSION_HEADER, Property.NodeScope));
    settings.add(Setting.simpleString(OPENSHIFT_ES_USER_PROFILE_PREFIX, Property.NodeScope));
    settings.add(Setting.listSetting(OPENSHIFT_CONFIG_OPS_PROJECTS,Arrays.asList(DEFAULT_OPENSHIFT_OPS_PROJECTS),
            Function.identity(), Property.NodeScope, Property.Dynamic));
    return settings;
}
 

static Setting<Integer> buildNumberOfShardsSetting() {
    /* This is a safety limit that should only be exceeded in very rare and special cases. The assumption is that
     * 99% of the users have less than 1024 shards per index. We also make it a hard check that requires restart of nodes
     * if a cluster should allow to create more than 1024 shards per index. NOTE: this does not limit the number of shards per cluster.
     * this also prevents creating stuff like a new index with millions of shards by accident which essentially kills the entire cluster
     * with OOM on the spot.*/
    final int maxNumShards = Integer.parseInt(System.getProperty("es.index.max_number_of_shards", "1024"));
    if (maxNumShards < 1) {
        throw new IllegalArgumentException("es.index.max_number_of_shards must be > 0");
    }
    return Setting.intSetting(SETTING_NUMBER_OF_SHARDS, Math.min(5, maxNumShards), 1, maxNumShards,
        Property.IndexScope, Property.Final);
}
 

public ClusterSettings(final Settings nodeSettings,
                       final List<Setting<?>> maskedSettings,
                       final Set<Setting<?>> settingsSet,
                       final Set<SettingUpgrader<?>> settingUpgraders) {
    super(nodeSettings, settingsSet, settingUpgraders, Property.NodeScope);
    this.maskedSettings = maskedSettings;
    addSettingsUpdater(new LoggingSettingUpdater(nodeSettings));
}
 

@Test
public void testMaskedSettingIsNotLogged() throws Exception {
    Settings oldSettings = Settings.builder().put("key", "old").build();
    Settings newSettings = Settings.builder().put("key", "new").build();

    Setting<String> filteredSetting = Setting.simpleString("key", Property.Masked);
    assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate(filteredSetting, newSettings, oldSettings, testLogger),
        new MockLogAppender.SeenEventExpectation("secure logging", "org.elasticsearch.test", Level.INFO, "updating [key]"),
        new MockLogAppender.UnseenEventExpectation("unwanted old setting name", "org.elasticsearch.test", Level.INFO, "*old*"),
        new MockLogAppender.UnseenEventExpectation("unwanted new setting name", "org.elasticsearch.test", Level.INFO, "*new*")
    );
}
 

@Test
public void testGet() {
    Setting<Boolean> booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope);
    assertFalse(booleanSetting.get(Settings.EMPTY));
    assertFalse(booleanSetting.get(Settings.builder().put("foo.bar", false).build()));
    assertTrue(booleanSetting.get(Settings.builder().put("foo.bar", true).build()));
}
 

@Test
public void testByteSizeSetting() {
    final Setting<ByteSizeValue> byteSizeValueSetting =
            Setting.byteSizeSetting("a.byte.size", new ByteSizeValue(1024), Property.Dynamic, Property.NodeScope);
    assertFalse(byteSizeValueSetting.isGroupSetting());
    final ByteSizeValue byteSizeValue = byteSizeValueSetting.get(Settings.EMPTY);
    assertThat(byteSizeValue.getBytes(), equalTo(1024L));
}
 

public void testByteSizeSettingValidation() {
    final Setting<ByteSizeValue> byteSizeValueSetting =
            Setting.byteSizeSetting("a.byte.size", s -> "2048b", Property.Dynamic, Property.NodeScope);
    final ByteSizeValue byteSizeValue = byteSizeValueSetting.get(Settings.EMPTY);
    assertThat(byteSizeValue.getBytes(), equalTo(2048L));
    AtomicReference<ByteSizeValue> value = new AtomicReference<>(null);
    ClusterSettings.SettingUpdater<ByteSizeValue> settingUpdater = byteSizeValueSetting.newUpdater(value::set, logger);
    assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12").build(), Settings.EMPTY));
    assertThat(value.get(), equalTo(new ByteSizeValue(12)));
    assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY));
    assertThat(value.get(), equalTo(new ByteSizeValue(12)));
}
 

public void testMemorySize() {
    Setting<ByteSizeValue> memorySizeValueSetting = Setting.memorySizeSetting("a.byte.size", new ByteSizeValue(1024), Property.Dynamic,
            Property.NodeScope);

    assertFalse(memorySizeValueSetting.isGroupSetting());
    ByteSizeValue memorySizeValue = memorySizeValueSetting.get(Settings.EMPTY);
    assertEquals(memorySizeValue.getBytes(), 1024);

    memorySizeValueSetting = Setting.memorySizeSetting("a.byte.size", s -> "2048b", Property.Dynamic, Property.NodeScope);
    memorySizeValue = memorySizeValueSetting.get(Settings.EMPTY);
    assertEquals(memorySizeValue.getBytes(), 2048);

    memorySizeValueSetting = Setting.memorySizeSetting("a.byte.size", "50%", Property.Dynamic, Property.NodeScope);
    assertFalse(memorySizeValueSetting.isGroupSetting());
    memorySizeValue = memorySizeValueSetting.get(Settings.EMPTY);
    assertEquals(memorySizeValue.getBytes(), JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.5, 1.0);

    memorySizeValueSetting = Setting.memorySizeSetting("a.byte.size", s -> "25%", Property.Dynamic, Property.NodeScope);
    memorySizeValue = memorySizeValueSetting.get(Settings.EMPTY);
    assertEquals(memorySizeValue.getBytes(), JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.25, 1.0);

    AtomicReference<ByteSizeValue> value = new AtomicReference<>(null);
    ClusterSettings.SettingUpdater<ByteSizeValue> settingUpdater = memorySizeValueSetting.newUpdater(value::set, logger);

    assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12").build(), Settings.EMPTY));
    assertEquals(new ByteSizeValue(12), value.get());

    assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY));
    assertEquals(new ByteSizeValue(12), value.get());

    assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "20%").build(), Settings.EMPTY));
    assertEquals(new ByteSizeValue((int) (JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.2)), value.get());
}
 

@Test
public void testSimpleUpdate() {
    Setting<Boolean> booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope);
    AtomicReference<Boolean> atomicBoolean = new AtomicReference<>(null);
    ClusterSettings.SettingUpdater<Boolean> settingUpdater = booleanSetting.newUpdater(atomicBoolean::set, logger);
    Settings build = Settings.builder().put("foo.bar", false).build();
    settingUpdater.apply(build, Settings.EMPTY);
    assertNull(atomicBoolean.get());
    build = Settings.builder().put("foo.bar", true).build();
    settingUpdater.apply(build, Settings.EMPTY);
    assertTrue(atomicBoolean.get());

    // try update bogus value
    build = Settings.builder().put("foo.bar", "I am not a boolean").build();
    try {
        settingUpdater.apply(build, Settings.EMPTY);
        fail("not a boolean");
    } catch (IllegalArgumentException ex) {
        assertThat(ex, hasToString(containsString("illegal value can't update [foo.bar] from [false] to [I am not a boolean]")));
        assertNotNull(ex.getCause());
        assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
        final IllegalArgumentException cause = (IllegalArgumentException) ex.getCause();
        assertThat(
                cause,
                hasToString(containsString("Failed to parse value [I am not a boolean] as only [true] or [false] are allowed.")));
    }
}
 

@AwaitsFix(bugUrl = "https://github.com/elastic/elasticsearch/issues/33135")
public void testValidateStringSetting() {
    Settings settings = Settings.builder().putList("foo.bar", Arrays.asList("bla-a", "bla-b")).build();
    Setting<String> stringSetting = Setting.simpleString("foo.bar", Property.NodeScope);
    IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> stringSetting.get(settings));
    assertEquals("Found list type value for setting [foo.bar] but but did not expect a list for it.", e.getMessage());
}
 

@Test
public void testUpdateNotDynamic() {
    Setting<Boolean> booleanSetting = Setting.boolSetting("foo.bar", false, Property.NodeScope);
    assertFalse(booleanSetting.isGroupSetting());
    AtomicReference<Boolean> atomicBoolean = new AtomicReference<>(null);
    try {
        booleanSetting.newUpdater(atomicBoolean::set, logger);
        fail("not dynamic");
    } catch (IllegalStateException ex) {
        assertEquals("setting [foo.bar] is not dynamic", ex.getMessage());
    }
}
 

@Test
public void testUpdaterIsIsolated() {
    Setting<Boolean> booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope);
    AtomicReference<Boolean> ab1 = new AtomicReference<>(null);
    AtomicReference<Boolean> ab2 = new AtomicReference<>(null);
    ClusterSettings.SettingUpdater<Boolean> settingUpdater = booleanSetting.newUpdater(ab1::set, logger);
    settingUpdater.apply(Settings.builder().put("foo.bar", true).build(), Settings.EMPTY);
    assertTrue(ab1.get());
    assertNull(ab2.get());
}
 

@Test
public void testDefault() {
    TimeValue defaultValue = TimeValue.timeValueMillis(randomIntBetween(0, 1000000));
    Setting<TimeValue> setting =
        Setting.positiveTimeSetting("my.time.value", defaultValue, Property.NodeScope);
    assertFalse(setting.isGroupSetting());
    String aDefault = setting.getDefaultRaw(Settings.EMPTY);
    assertEquals(defaultValue.millis() + "ms", aDefault);
    assertEquals(defaultValue.millis(), setting.get(Settings.EMPTY).millis());
    assertEquals(defaultValue, setting.getDefault(Settings.EMPTY));

    Setting<String> secondaryDefault =
        new Setting<>("foo.bar", (s) -> s.get("old.foo.bar", "some_default"), Function.identity(), Property.NodeScope);
    assertEquals("some_default", secondaryDefault.get(Settings.EMPTY));
    assertEquals("42", secondaryDefault.get(Settings.builder().put("old.foo.bar", 42).build()));

    Setting<String> secondaryDefaultViaSettings =
        new Setting<>("foo.bar", secondaryDefault, Function.identity(), Property.NodeScope);
    assertEquals("some_default", secondaryDefaultViaSettings.get(Settings.EMPTY));
    assertEquals("42", secondaryDefaultViaSettings.get(Settings.builder().put("old.foo.bar", 42).build()));

    // It gets more complicated when there are two settings objects....
    Settings hasFallback = Settings.builder().put("foo.bar", "o").build();
    Setting<String> fallsback =
            new Setting<>("foo.baz", secondaryDefault, Function.identity(), Property.NodeScope);
    assertEquals("o", fallsback.get(hasFallback));
    assertEquals("some_default", fallsback.get(Settings.EMPTY));
    assertEquals("some_default", fallsback.get(Settings.EMPTY, Settings.EMPTY));
    assertEquals("o", fallsback.get(Settings.EMPTY, hasFallback));
    assertEquals("o", fallsback.get(hasFallback, Settings.EMPTY));
    assertEquals("a", fallsback.get(
            Settings.builder().put("foo.bar", "a").build(),
            Settings.builder().put("foo.bar", "b").build()));
}
 

@Test
public void testType() {
    Setting<Integer> integerSetting = Setting.intSetting("foo.int.bar", 1, Property.Dynamic, Property.NodeScope);
    assertThat(integerSetting.hasNodeScope(), is(true));
    assertThat(integerSetting.hasIndexScope(), is(false));
    integerSetting = Setting.intSetting("foo.int.bar", 1, Property.Dynamic, Property.IndexScope);
    assertThat(integerSetting.hasIndexScope(), is(true));
    assertThat(integerSetting.hasNodeScope(), is(false));
}
 

@Test
public void testComposite() {
    Composite c = new Composite();
    Setting<Integer> a = Setting.intSetting("foo.int.bar.a", 1, Property.Dynamic, Property.NodeScope);
    Setting<Integer> b = Setting.intSetting("foo.int.bar.b", 1, Property.Dynamic, Property.NodeScope);
    ClusterSettings.SettingUpdater<Tuple<Integer, Integer>> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b, logger);
    assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY));
    assertNull(c.a);
    assertNull(c.b);

    Settings build = Settings.builder().put("foo.int.bar.a", 2).build();
    assertTrue(settingUpdater.apply(build, Settings.EMPTY));
    assertEquals(2, c.a.intValue());
    assertEquals(1, c.b.intValue());

    Integer aValue = c.a;
    assertFalse(settingUpdater.apply(build, build));
    assertSame(aValue, c.a);
    Settings previous = build;
    build = Settings.builder().put("foo.int.bar.a", 2).put("foo.int.bar.b", 5).build();
    assertTrue(settingUpdater.apply(build, previous));
    assertEquals(2, c.a.intValue());
    assertEquals(5, c.b.intValue());

    // reset to default
    assertTrue(settingUpdater.apply(Settings.EMPTY, build));
    assertEquals(1, c.a.intValue());
    assertEquals(1, c.b.intValue());

}
 

@Test
public void testCompositeValidator() {
    Composite c = new Composite();
    Setting<Integer> a = Setting.intSetting("foo.int.bar.a", 1, Property.Dynamic, Property.NodeScope);
    Setting<Integer> b = Setting.intSetting("foo.int.bar.b", 1, Property.Dynamic, Property.NodeScope);
    ClusterSettings.SettingUpdater<Tuple<Integer, Integer>> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b, logger);
    assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY));
    assertNull(c.a);
    assertNull(c.b);

    Settings build = Settings.builder().put("foo.int.bar.a", 2).build();
    assertTrue(settingUpdater.apply(build, Settings.EMPTY));
    assertEquals(2, c.a.intValue());
    assertEquals(1, c.b.intValue());

    Integer aValue = c.a;
    assertFalse(settingUpdater.apply(build, build));
    assertSame(aValue, c.a);
    Settings previous = build;
    build = Settings.builder().put("foo.int.bar.a", 2).put("foo.int.bar.b", 5).build();
    assertTrue(settingUpdater.apply(build, previous));
    assertEquals(2, c.a.intValue());
    assertEquals(5, c.b.intValue());

    Settings invalid = Settings.builder().put("foo.int.bar.a", -2).put("foo.int.bar.b", 5).build();
    IllegalArgumentException exc = expectThrows(IllegalArgumentException.class, () -> settingUpdater.apply(invalid, previous));
    assertThat(exc.getMessage(), equalTo("boom"));

    // reset to default
    assertTrue(settingUpdater.apply(Settings.EMPTY, build));
    assertEquals(1, c.a.intValue());
    assertEquals(1, c.b.intValue());

}
 

@Test
public void testAffixKeySetting() {
    Setting<Boolean> setting =
        Setting.affixKeySetting("foo.", "enable", (key) -> Setting.boolSetting(key, false, Property.NodeScope));
    assertTrue(setting.hasComplexMatcher());
    assertTrue(setting.match("foo.bar.enable"));
    assertTrue(setting.match("foo.baz.enable"));
    assertFalse(setting.match("foo.bar.baz.enable"));
    assertFalse(setting.match("foo.bar"));
    assertFalse(setting.match("foo.bar.baz.enabled"));
    assertFalse(setting.match("foo"));
    Setting<Boolean> concreteSetting = setting.getConcreteSetting("foo.bar.enable");
    assertTrue(concreteSetting.get(Settings.builder().put("foo.bar.enable", "true").build()));
    assertFalse(concreteSetting.get(Settings.builder().put("foo.baz.enable", "true").build()));

    IllegalArgumentException exc = expectThrows(IllegalArgumentException.class, () -> setting.getConcreteSetting("foo"));
    assertEquals("key [foo] must match [foo.*.enable] but didn't.", exc.getMessage());

    exc = expectThrows(IllegalArgumentException.class, () -> Setting.affixKeySetting("foo", "enable",
        (key) -> Setting.boolSetting(key, false, Property.NodeScope)));
    assertEquals("prefix must end with a '.'", exc.getMessage());

    Setting<List<String>> listAffixSetting = Setting.affixKeySetting("foo.", "bar",
        (key) -> Setting.listSetting(key, Collections.emptyList(), Function.identity(), Property.NodeScope));

    assertTrue(listAffixSetting.hasComplexMatcher());
    assertTrue(listAffixSetting.match("foo.test.bar"));
    assertTrue(listAffixSetting.match("foo.test_1.bar"));
    assertFalse(listAffixSetting.match("foo.buzz.baz.bar"));
    assertFalse(listAffixSetting.match("foo.bar"));
    assertFalse(listAffixSetting.match("foo.baz"));
    assertFalse(listAffixSetting.match("foo"));
}
 

@Test
public void testAffixSettingsFailOnGet() {
    Setting.AffixSetting<List<String>> listAffixSetting = Setting.affixKeySetting("foo.", "bar",
        (key) -> Setting.listSetting(key, Collections.singletonList("testelement"), Function.identity(), Property.NodeScope));
    expectThrows(UnsupportedOperationException.class, () -> listAffixSetting.get(Settings.EMPTY));
    expectThrows(UnsupportedOperationException.class, () -> listAffixSetting.getRaw(Settings.EMPTY));
    assertEquals(Collections.singletonList("testelement"), listAffixSetting.getDefault(Settings.EMPTY));
    assertEquals("[\"testelement\"]", listAffixSetting.getDefaultRaw(Settings.EMPTY));
}
 

/**
 * We can't have Null properties
 */
@Test
public void testRejectNullProperties() {
    IllegalArgumentException ex = expectThrows(IllegalArgumentException.class,
        () -> Setting.simpleString("foo.bar", (Property[]) null));
    assertThat(ex.getMessage(), containsString("properties cannot be null for setting"));
}