Java 类org.elasticsearch.common.settings.Setting.Property 实例源码

public void testListener() throws IOException {
    Setting<Boolean> booleanSetting = Setting.boolSetting("index.foo.bar", false, Property.Dynamic, Property.IndexScope);
    IndexModule module = new IndexModule(IndexSettingsModule.newIndexSettings(index, settings, booleanSetting),
            new AnalysisRegistry(environment, emptyMap(), emptyMap(), emptyMap(), emptyMap(), emptyMap()));
    Setting<Boolean> booleanSetting2 = Setting.boolSetting("index.foo.bar.baz", false, Property.Dynamic, Property.IndexScope);
    AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    module.addSettingsUpdateConsumer(booleanSetting, atomicBoolean::set);

    try {
        module.addSettingsUpdateConsumer(booleanSetting2, atomicBoolean::set);
        fail("not registered");
    } catch (IllegalArgumentException ex) {

    }

    IndexService indexService = newIndexService(module);
    assertSame(booleanSetting, indexService.getIndexSettings().getScopedSettings().get(booleanSetting.getKey()));

    indexService.close("simon says", false);
}

public void testRunListener() {
    Version version = VersionUtils.getPreviousVersion();
    Settings theSettings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, version)
        .put(IndexMetaData.SETTING_INDEX_UUID, "0xdeadbeef").build();
    final AtomicInteger integer = new AtomicInteger(0);
    Setting<Integer> integerSetting = Setting.intSetting("index.test.setting.int", -1,
        Property.Dynamic, Property.IndexScope);
    IndexMetaData metaData = newIndexMeta("index", theSettings);
    IndexSettings settings = newIndexSettings(newIndexMeta("index", theSettings), Settings.EMPTY, integerSetting);
    settings.getScopedSettings().addSettingsUpdateConsumer(integerSetting, integer::set);

    assertEquals(version, settings.getIndexVersionCreated());
    assertEquals("0xdeadbeef", settings.getUUID());

    assertFalse(settings.updateIndexMetaData(metaData));
    assertEquals(metaData.getSettings().getAsMap(), settings.getSettings().getAsMap());
    assertEquals(0, integer.get());
    assertTrue(settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(theSettings).put("index.test.setting.int", 42)
        .build())));
    assertEquals(42, integer.get());
}

public void testSettingsUpdateValidator() {
    Version version = VersionUtils.getPreviousVersion();
    Settings theSettings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, version)
        .put(IndexMetaData.SETTING_INDEX_UUID, "0xdeadbeef").build();
    final AtomicInteger integer = new AtomicInteger(0);
    Setting<Integer> integerSetting = Setting.intSetting("index.test.setting.int", -1,
        Property.Dynamic, Property.IndexScope);
    IndexMetaData metaData = newIndexMeta("index", theSettings);
    IndexSettings settings = newIndexSettings(newIndexMeta("index", theSettings), Settings.EMPTY, integerSetting);
    settings.getScopedSettings().addSettingsUpdateConsumer(integerSetting, integer::set,
        (i) -> {if (i == 42) throw new AssertionError("boom");});

    assertEquals(version, settings.getIndexVersionCreated());
    assertEquals("0xdeadbeef", settings.getUUID());

    assertFalse(settings.updateIndexMetaData(metaData));
    assertEquals(metaData.getSettings().getAsMap(), settings.getSettings().getAsMap());
    assertEquals(0, integer.get());
    expectThrows(IllegalArgumentException.class, () -> settings.updateIndexMetaData(newIndexMeta("index",
        Settings.builder().put(theSettings).put("index.test.setting.int", 42).build())));
    assertTrue(settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().put(theSettings).put("index.test.setting.int", 41)
        .build())));
    assertEquals(41, integer.get());
}

public void testByteSize() {
    Setting<ByteSizeValue> byteSizeValueSetting =
        Setting.byteSizeSetting("a.byte.size", new ByteSizeValue(1024), Property.Dynamic, Property.NodeScope);
    assertFalse(byteSizeValueSetting.isGroupSetting());
    ByteSizeValue byteSizeValue = byteSizeValueSetting.get(Settings.EMPTY);
    assertEquals(byteSizeValue.getBytes(), 1024);

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


    AtomicReference<ByteSizeValue> value = new AtomicReference<>(null);
    ClusterSettings.SettingUpdater<ByteSizeValue> settingUpdater = byteSizeValueSetting.newUpdater(value::set, logger);
    try {
        settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY);
        fail("no unit");
    } catch (IllegalArgumentException ex) {
        assertEquals("failed to parse setting [a.byte.size] with value [12] as a size in bytes: unit is missing or unrecognized",
                ex.getMessage());
    }

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

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) {
        assertEquals("Failed to parse value [I am not a boolean] as only [true] or [false] are allowed.",
                ex.getMessage());
    }
}

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);
}

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());
    }
}

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()
        .putArray("foo.1.bar", "1", "2")
        .putArray("foo.2.bar", "3", "4", "5")
        .putArray("foo.bar", "6")
        .putArray("some.other", "6")
        .putArray("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
 */
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));
}

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());
        }
    }
}

public void testRegisterSettingsFilter() {
    Settings settings = Settings.builder().put("foo.bar", "false").put("bar.foo", false).put("bar.baz", false).build();
    try {
        new SettingsModule(settings, Arrays.asList(Setting.boolSetting("foo.bar", true, Property.NodeScope),
        Setting.boolSetting("bar.foo", true, Property.NodeScope, Property.Filtered),
        Setting.boolSetting("bar.baz", true, Property.NodeScope)), Arrays.asList("foo.*", "bar.foo"));
        fail();
    } catch (IllegalArgumentException ex) {
        assertEquals("filter [bar.foo] has already been registered", ex.getMessage());
    }
    SettingsModule module = new SettingsModule(settings, Arrays.asList(Setting.boolSetting("foo.bar", true, Property.NodeScope),
        Setting.boolSetting("bar.foo", true, Property.NodeScope, Property.Filtered),
        Setting.boolSetting("bar.baz", true, Property.NodeScope)), Arrays.asList("foo.*"));
    assertInstanceBinding(module, Settings.class, (s) -> s == settings);
    assertInstanceBinding(module, SettingsFilter.class, (s) -> s.filter(settings).size() == 1);
    assertInstanceBinding(module, SettingsFilter.class, (s) -> s.filter(settings).getAsMap().containsKey("bar.baz"));
    assertInstanceBinding(module, SettingsFilter.class, (s) -> s.filter(settings).getAsMap().get("bar.baz").equals("false"));

}

public void testRegisterShared() {
    Property scope = randomFrom(Property.NodeScope, Property.IndexScope);
    expectThrows(IllegalArgumentException.class, () ->
        new SettingsModule(Settings.EMPTY,
            Setting.simpleString("index.foo.bar", scope), Setting.simpleString("index.foo.bar", scope))
    );
    expectThrows(IllegalArgumentException.class, () ->
        new SettingsModule(Settings.EMPTY,
            Setting.simpleString("index.foo.bar", scope, Property.Shared), Setting.simpleString("index.foo.bar", scope))
    );
    expectThrows(IllegalArgumentException.class, () ->
        new SettingsModule(Settings.EMPTY,
            Setting.simpleString("index.foo.bar", scope), Setting.simpleString("index.foo.bar", scope, Property.Shared))
    );
    new SettingsModule(Settings.EMPTY,
        Setting.simpleString("index.foo.bar", scope, Property.Shared),
        Setting.simpleString("index.foo.bar", scope, Property.Shared));
}

private static Map<ScriptContext, Setting<Boolean>> contextSettings(ScriptContextRegistry scriptContextRegistry) {
    Map<ScriptContext, Setting<Boolean>> scriptContextSettingMap = new HashMap<>();
    for (ScriptContext scriptContext : scriptContextRegistry.scriptContexts()) {
        scriptContextSettingMap.put(scriptContext,
                Setting.boolSetting(ScriptModes.operationKey(scriptContext), false, Property.NodeScope));
    }
    return scriptContextSettingMap;
}

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);
}

public void testNodeSettingsAreContained() {
    final int numShards = randomIntBetween(1, 10);
    final int numReplicas = randomIntBetween(0, 10);
    Settings theSettings = Settings.builder().
            put("index.foo.bar", 0)
            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, numReplicas)
            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, numShards).build();

    Settings nodeSettings = Settings.builder().put("index.foo.bar", 43).build();
    final AtomicInteger indexValue = new AtomicInteger(0);
    Setting<Integer> integerSetting = Setting.intSetting("index.foo.bar", -1, Property.Dynamic, Property.IndexScope);
    IndexSettings settings = newIndexSettings(newIndexMeta("index", theSettings), nodeSettings, integerSetting);
    settings.getScopedSettings().addSettingsUpdateConsumer(integerSetting, indexValue::set);
    assertEquals(numReplicas, settings.getNumberOfReplicas());
    assertEquals(numShards, settings.getNumberOfShards());
    assertEquals(0, indexValue.get());

    assertTrue(settings.updateIndexMetaData(newIndexMeta("index", Settings.builder().
            put("index.foo.bar", 42)
            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, numReplicas + 1)
            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, numShards).build())));

    assertEquals(42, indexValue.get());
    assertSame(nodeSettings, settings.getNodeSettings());

    assertTrue(settings.updateIndexMetaData(newIndexMeta("index", Settings.builder()
        .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, numReplicas + 1)
        .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, numShards).build())));
    assertEquals(43, indexValue.get());

}

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);
    try {
        settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY);
        fail("no unit");
    } catch (IllegalArgumentException ex) {
        assertEquals("failed to parse setting [a.byte.size] with value [12] as a size in bytes: unit is missing or unrecognized",
                ex.getMessage());
    }

    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());
}

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());
    }
}

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());
}

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()));
}

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));
}

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, 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());

}

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"));
}

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
 */
public void testRejectNullProperties() {
    try {
        Setting.simpleString("foo.bar", (Property[]) null);
        fail();
    } catch (IllegalArgumentException ex) {
        assertThat(ex.getMessage(), containsString("properties cannot be null for setting"));
    }
}

private void assertMemorySizeSetting(Setting<ByteSizeValue> setting, String settingKey, ByteSizeValue defaultValue) {
    assertThat(setting, notNullValue());
    assertThat(setting.getKey(), equalTo(settingKey));
    assertThat(setting.getProperties(), hasItem(Property.NodeScope));
    assertThat(setting.getDefault(Settings.EMPTY),
            equalTo(defaultValue));
    Settings settingWithPercentage = Settings.builder().put(settingKey, "25%").build();
    assertThat(setting.get(settingWithPercentage),
            equalTo(new ByteSizeValue((long) (JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.25))));
    Settings settingWithBytesValue = Settings.builder().put(settingKey, "1024b").build();
    assertThat(setting.get(settingWithBytesValue), equalTo(new ByteSizeValue(1024)));
}

public void testIsDynamic(){
    ClusterSettings settings =
        new ClusterSettings(Settings.EMPTY,
            new HashSet<>(Arrays.asList(Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope),
                Setting.intSetting("foo.bar.baz", 1, Property.NodeScope))));
    assertFalse(settings.hasDynamicSetting("foo.bar.baz"));
    assertTrue(settings.hasDynamicSetting("foo.bar"));
    assertNotNull(settings.get("foo.bar.baz"));
    settings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
    assertTrue(settings.hasDynamicSetting("transport.tracer.include." + randomIntBetween(1, 100)));
    assertFalse(settings.hasDynamicSetting("transport.tracer.include.BOOM"));
    assertTrue(settings.hasDynamicSetting("cluster.routing.allocation.require.value"));
}

public ClusterSettings(Settings nodeSettings, Set<Setting<?>> settingsSet) {
    super(nodeSettings, settingsSet, Property.NodeScope);
    addSettingsUpdater(new LoggingSettingUpdater(nodeSettings));
}

public IndexScopedSettings(Settings settings, Set<Setting<?>> settingsSet) {
    super(settings, settingsSet, Property.IndexScope);
}

public void testRegisterClusterDynamicSetting() {
    SettingsModule module = new SettingsModule(Settings.EMPTY,
        Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope));
    assertInstanceBinding(module, ClusterSettings.class, service -> service.hasDynamicSetting("foo.bar"));
}

public void testRegisterIndexDynamicSetting() {
    SettingsModule module = new SettingsModule(Settings.EMPTY,
        Setting.boolSetting("index.foo.bar", false, Property.Dynamic, Property.IndexScope));
    assertInstanceBinding(module, IndexScopedSettings.class, service -> service.hasDynamicSetting("index.foo.bar"));
}

@Override
public List<Setting<?>> getSettings() {
    return Arrays.asList(SOME_NODE_SETTING,
    SOME_OTHER_NODE_SETTING,
    Setting.groupSetting("index.filter_test.", Property.IndexScope));
}

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()));
}

public void testGroups() {
    AtomicReference<Settings> ref = new AtomicReference<>(null);
    Setting<Settings> setting = Setting.groupSetting("foo.bar.", Property.Dynamic, Property.NodeScope);
    assertTrue(setting.isGroupSetting());
    ClusterSettings.SettingUpdater<Settings> settingUpdater = setting.newUpdater(ref::set, logger);

    Settings currentInput = Settings.builder()
            .put("foo.bar.1.value", "1")
            .put("foo.bar.2.value", "2")
            .put("foo.bar.3.value", "3").build();
    Settings previousInput = Settings.EMPTY;
    assertTrue(settingUpdater.apply(currentInput, previousInput));
    assertNotNull(ref.get());
    Settings settings = ref.get();
    Map<String, Settings> asMap = settings.getAsGroups();
    assertEquals(3, asMap.size());
    assertEquals(asMap.get("1").get("value"), "1");
    assertEquals(asMap.get("2").get("value"), "2");
    assertEquals(asMap.get("3").get("value"), "3");

    previousInput = currentInput;
    currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").put("foo.bar.3.value", "3").build();
    Settings current = ref.get();
    assertFalse(settingUpdater.apply(currentInput, previousInput));
    assertSame(current, ref.get());

    previousInput = currentInput;
    currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build();
    // now update and check that we got it
    assertTrue(settingUpdater.apply(currentInput, previousInput));
    assertNotSame(current, ref.get());

    asMap = ref.get().getAsGroups();
    assertEquals(2, asMap.size());
    assertEquals(asMap.get("1").get("value"), "1");
    assertEquals(asMap.get("2").get("value"), "2");

    previousInput = currentInput;
    currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "4").build();
    // now update and check that we got it
    assertTrue(settingUpdater.apply(currentInput, previousInput));
    assertNotSame(current, ref.get());

    asMap = ref.get().getAsGroups();
    assertEquals(2, asMap.size());
    assertEquals(asMap.get("1").get("value"), "1");
    assertEquals(asMap.get("2").get("value"), "4");

    assertTrue(setting.match("foo.bar.baz"));
    assertFalse(setting.match("foo.baz.bar"));

    ClusterSettings.SettingUpdater<Settings> predicateSettingUpdater = setting.newUpdater(ref::set, logger,(s) -> assertFalse(true));
    try {
        predicateSettingUpdater.apply(Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build(),
                Settings.EMPTY);
        fail("not accepted");
    } catch (IllegalArgumentException ex) {
        assertEquals(ex.getMessage(), "illegal value can't update [foo.bar.] from [{}] to [{1.value=1, 2.value=2}]");
    }
}

public void testListSettings() {
    Setting<List<String>> listSetting = Setting.listSetting("foo.bar", Arrays.asList("foo,bar"), (s) -> s.toString(),
        Property.Dynamic, Property.NodeScope);
    List<String> value = listSetting.get(Settings.EMPTY);
    assertFalse(listSetting.exists(Settings.EMPTY));
    assertEquals(1, value.size());
    assertEquals("foo,bar", value.get(0));

    List<String> input = Arrays.asList("test", "test1, test2", "test", ",,,,");
    Settings.Builder builder = Settings.builder().putArray("foo.bar", input.toArray(new String[0]));
    assertTrue(listSetting.exists(builder.build()));
    value = listSetting.get(builder.build());
    assertEquals(input.size(), value.size());
    assertArrayEquals(value.toArray(new String[0]), input.toArray(new String[0]));

    // try to parse this really annoying format
    builder = Settings.builder();
    for (int i = 0; i < input.size(); i++) {
        builder.put("foo.bar." + i, input.get(i));
    }
    value = listSetting.get(builder.build());
    assertEquals(input.size(), value.size());
    assertArrayEquals(value.toArray(new String[0]), input.toArray(new String[0]));
    assertTrue(listSetting.exists(builder.build()));

    AtomicReference<List<String>> ref = new AtomicReference<>();
    AbstractScopedSettings.SettingUpdater<List<String>> settingUpdater = listSetting.newUpdater(ref::set, logger);
    assertTrue(settingUpdater.hasChanged(builder.build(), Settings.EMPTY));
    settingUpdater.apply(builder.build(), Settings.EMPTY);
    assertEquals(input.size(), ref.get().size());
    assertArrayEquals(ref.get().toArray(new String[0]), input.toArray(new String[0]));

    settingUpdater.apply(Settings.builder().putArray("foo.bar", "123").build(), builder.build());
    assertEquals(1, ref.get().size());
    assertArrayEquals(ref.get().toArray(new String[0]), new String[] {"123"});

    settingUpdater.apply(Settings.builder().put("foo.bar", "1,2,3").build(), Settings.builder().putArray("foo.bar", "123").build());
    assertEquals(3, ref.get().size());
    assertArrayEquals(ref.get().toArray(new String[0]), new String[] {"1", "2", "3"});

    settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "1,2,3").build());
    assertEquals(1, ref.get().size());
    assertEquals("foo,bar", ref.get().get(0));

    Setting<List<Integer>> otherSettings = Setting.listSetting("foo.bar", Collections.emptyList(), Integer::parseInt,
        Property.Dynamic, Property.NodeScope);
    List<Integer> defaultValue = otherSettings.get(Settings.EMPTY);
    assertEquals(0, defaultValue.size());
    List<Integer> intValues = otherSettings.get(Settings.builder().put("foo.bar", "0,1,2,3").build());
    assertEquals(4, intValues.size());
    for (int i = 0; i < intValues.size(); i++) {
        assertEquals(i, intValues.get(i).intValue());
    }

    Setting<List<String>> settingWithFallback = Setting.listSetting("foo.baz", listSetting, Function.identity(),
        Property.Dynamic, Property.NodeScope);
    value = settingWithFallback.get(Settings.EMPTY);
    assertEquals(1, value.size());
    assertEquals("foo,bar", value.get(0));

    value = settingWithFallback.get(Settings.builder().putArray("foo.bar", "1", "2").build());
    assertEquals(2, value.size());
    assertEquals("1", value.get(0));
    assertEquals("2", value.get(1));

    value = settingWithFallback.get(Settings.builder().putArray("foo.baz", "3", "4").build());
    assertEquals(2, value.size());
    assertEquals("3", value.get(0));
    assertEquals("4", value.get(1));

    value = settingWithFallback.get(Settings.builder().putArray("foo.baz", "3", "4").putArray("foo.bar", "1", "2").build());
    assertEquals(2, value.size());
    assertEquals("3", value.get(0));
    assertEquals("4", value.get(1));
}

public void testResetSetting() {
    Setting<Integer> dynamicSetting = Setting.intSetting("some.dyn.setting", 1, Property.Dynamic, Property.NodeScope);
    Setting<Integer> staticSetting = Setting.intSetting("some.static.setting", 1, Property.NodeScope);
    Settings currentSettings = Settings.builder().put("some.dyn.setting", 5).put("some.static.setting", 6).put("archived.foo.bar", 9)
        .build();
    ClusterSettings service = new ClusterSettings(currentSettings
        , new HashSet<>(Arrays.asList(dynamicSetting, staticSetting)));

    expectThrows(IllegalArgumentException.class, () ->
    service.updateDynamicSettings(Settings.builder().put("some.dyn.setting", 8).putNull("some.static.setting").build(),
        Settings.builder().put(currentSettings), Settings.builder(), "node"));

    Settings.Builder target = Settings.builder().put(currentSettings);
    Settings.Builder update = Settings.builder();
    assertTrue(service.updateDynamicSettings(Settings.builder().put("some.dyn.setting", 8).build(),
        target, update, "node"));
    assertEquals(8, dynamicSetting.get(target.build()).intValue());
    assertEquals(6, staticSetting.get(target.build()).intValue());
    assertEquals(9, target.build().getAsInt("archived.foo.bar", null).intValue());

    target = Settings.builder().put(currentSettings);
    update = Settings.builder();
    assertTrue(service.updateDynamicSettings(Settings.builder().putNull("some.dyn.setting").build(),
        target, update, "node"));
    assertEquals(1, dynamicSetting.get(target.build()).intValue());
    assertEquals(6, staticSetting.get(target.build()).intValue());
    assertEquals(9, target.build().getAsInt("archived.foo.bar", null).intValue());

    target = Settings.builder().put(currentSettings);
    update = Settings.builder();
    assertTrue(service.updateDynamicSettings(Settings.builder().putNull("archived.foo.bar").build(),
        target, update, "node"));
    assertEquals(5, dynamicSetting.get(target.build()).intValue());
    assertEquals(6, staticSetting.get(target.build()).intValue());
    assertNull(target.build().getAsInt("archived.foo.bar", null));

    target = Settings.builder().put(currentSettings);
    update = Settings.builder();
    assertTrue(service.updateDynamicSettings(Settings.builder().putNull("some.*").build(),
        target, update, "node"));
    assertEquals(1, dynamicSetting.get(target.build()).intValue());
    assertEquals(6, staticSetting.get(target.build()).intValue());
    assertEquals(9, target.build().getAsInt("archived.foo.bar", null).intValue());

    target = Settings.builder().put(currentSettings);
    update = Settings.builder();
    assertTrue(service.updateDynamicSettings(Settings.builder().putNull("*").build(),
        target, update, "node"));
    assertEquals(1, dynamicSetting.get(target.build()).intValue());
    assertEquals(6, staticSetting.get(target.build()).intValue());
    assertNull(target.build().getAsInt("archived.foo.bar", null));
}

public void testAddConsumerAffix() {
    Setting.AffixSetting<Integer> intSetting = Setting.affixKeySetting("foo.", "bar",
        (k) ->  Setting.intSetting(k, 1, Property.Dynamic, Property.NodeScope));
    Setting.AffixSetting<List<Integer>> listSetting = Setting.affixKeySetting("foo.", "list",
        (k) -> Setting.listSetting(k, Arrays.asList("1"), Integer::parseInt, Property.Dynamic, Property.NodeScope));
    AbstractScopedSettings service = new ClusterSettings(Settings.EMPTY,new HashSet<>(Arrays.asList(intSetting, listSetting)));
    Map<String, List<Integer>> listResults = new HashMap<>();
    Map<String, Integer> intResults = new HashMap<>();

    BiConsumer<String, Integer> intConsumer = intResults::put;
    BiConsumer<String, List<Integer>> listConsumer = listResults::put;

    service.addAffixUpdateConsumer(listSetting, listConsumer, (s, k) -> {});
    service.addAffixUpdateConsumer(intSetting, intConsumer, (s, k) -> {});
    assertEquals(0, listResults.size());
    assertEquals(0, intResults.size());
    service.applySettings(Settings.builder()
        .put("foo.test.bar", 2)
        .put("foo.test_1.bar", 7)
        .putArray("foo.test_list.list", "16", "17")
        .putArray("foo.test_list_1.list", "18", "19", "20")
        .build());
    assertEquals(2, intResults.get("test").intValue());
    assertEquals(7, intResults.get("test_1").intValue());
    assertEquals(Arrays.asList(16, 17), listResults.get("test_list"));
    assertEquals(Arrays.asList(18, 19, 20), listResults.get("test_list_1"));
    assertEquals(2, listResults.size());
    assertEquals(2, intResults.size());

    listResults.clear();
    intResults.clear();

    service.applySettings(Settings.builder()
        .put("foo.test.bar", 2)
        .put("foo.test_1.bar", 8)
        .putArray("foo.test_list.list", "16", "17")
        .putNull("foo.test_list_1.list")
        .build());
    assertNull("test wasn't changed", intResults.get("test"));
    assertEquals(8, intResults.get("test_1").intValue());
    assertNull("test_list wasn't changed", listResults.get("test_list"));
    assertEquals(Arrays.asList(1), listResults.get("test_list_1")); // reset to default
    assertEquals(1, listResults.size());
    assertEquals(1, intResults.size());
}

public void testDiff() throws IOException {
    Setting<Integer> fooBarBaz = Setting.intSetting("foo.bar.baz", 1, Property.NodeScope);
    Setting<Integer> fooBar = Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope);
    Setting<Settings> someGroup = Setting.groupSetting("some.group.", Property.Dynamic, Property.NodeScope);
    Setting<Boolean> someAffix = Setting.affixKeySetting("some.prefix.", "somekey", (key) -> Setting.boolSetting(key, true,
        Property.NodeScope));
    Setting<List<String>> foorBarQuux =
            Setting.listSetting("foo.bar.quux", Arrays.asList("a", "b", "c"), Function.identity(), Property.NodeScope);
    ClusterSettings settings = new ClusterSettings(Settings.EMPTY, new HashSet<>(Arrays.asList(fooBar, fooBarBaz, foorBarQuux,
        someGroup, someAffix)));
    Settings diff = settings.diff(Settings.builder().put("foo.bar", 5).build(), Settings.EMPTY);
    assertEquals(4, diff.size()); // 4 since foo.bar.quux has 3 values essentially
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(1));
    assertArrayEquals(diff.getAsArray("foo.bar.quux", null), new String[] {"a", "b", "c"});

    diff = settings.diff(
            Settings.builder().put("foo.bar", 5).build(),
            Settings.builder().put("foo.bar.baz", 17).putArray("foo.bar.quux", "d", "e", "f").build());
    assertEquals(4, diff.size()); // 4 since foo.bar.quux has 3 values essentially
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(17));
    assertArrayEquals(diff.getAsArray("foo.bar.quux", null), new String[] {"d", "e", "f"});

    diff = settings.diff(
        Settings.builder().put("some.group.foo", 5).build(),
        Settings.builder().put("some.group.foobar", 17, "some.group.foo", 25).build());
    assertEquals(6, diff.size()); // 6 since foo.bar.quux has 3 values essentially
    assertThat(diff.getAsInt("some.group.foobar", null), equalTo(17));
    assertNull(diff.get("some.group.foo"));
    assertArrayEquals(diff.getAsArray("foo.bar.quux", null), new String[] {"a", "b", "c"});
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(1));
    assertThat(diff.getAsInt("foo.bar", null), equalTo(1));

    diff = settings.diff(
        Settings.builder().put("some.prefix.foo.somekey", 5).build(),
        Settings.builder().put("some.prefix.foobar.somekey", 17,
            "some.prefix.foo.somekey", 18).build());
    assertEquals(6, diff.size()); // 6 since foo.bar.quux has 3 values essentially
    assertThat(diff.getAsInt("some.prefix.foobar.somekey", null), equalTo(17));
    assertNull(diff.get("some.prefix.foo.somekey"));
    assertArrayEquals(diff.getAsArray("foo.bar.quux", null), new String[] {"a", "b", "c"});
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(1));
    assertThat(diff.getAsInt("foo.bar", null), equalTo(1));
}

public void testDiffWithAffixAndComplexMatcher() {
    Setting<Integer> fooBarBaz = Setting.intSetting("foo.bar.baz", 1, Property.NodeScope);
    Setting<Integer> fooBar = Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope);
    Setting<Settings> someGroup = Setting.groupSetting("some.group.", Property.Dynamic, Property.NodeScope);
    Setting<Boolean> someAffix = Setting.affixKeySetting("some.prefix.", "somekey", (key) -> Setting.boolSetting(key, true,
        Property.NodeScope));
    Setting<List<String>> foorBarQuux = Setting.affixKeySetting("foo.", "quux",
        (key) -> Setting.listSetting(key,  Arrays.asList("a", "b", "c"), Function.identity(), Property.NodeScope));
    ClusterSettings settings = new ClusterSettings(Settings.EMPTY, new HashSet<>(Arrays.asList(fooBar, fooBarBaz, foorBarQuux,
        someGroup, someAffix)));
    Settings diff = settings.diff(Settings.builder().put("foo.bar", 5).build(), Settings.EMPTY);
    assertEquals(1, diff.size());
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(1));
    assertNull(diff.getAsArray("foo.bar.quux", null)); // affix settings don't know their concrete keys

    diff = settings.diff(
        Settings.builder().put("foo.bar", 5).build(),
        Settings.builder().put("foo.bar.baz", 17).putArray("foo.bar.quux", "d", "e", "f").build());
    assertEquals(4, diff.size());
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(17));
    assertArrayEquals(diff.getAsArray("foo.bar.quux", null), new String[] {"d", "e", "f"});

    diff = settings.diff(
        Settings.builder().put("some.group.foo", 5).build(),
        Settings.builder().put("some.group.foobar", 17, "some.group.foo", 25).build());
    assertEquals(3, diff.size());
    assertThat(diff.getAsInt("some.group.foobar", null), equalTo(17));
    assertNull(diff.get("some.group.foo"));
    assertNull(diff.getAsArray("foo.bar.quux", null)); // affix settings don't know their concrete keys
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(1));
    assertThat(diff.getAsInt("foo.bar", null), equalTo(1));

    diff = settings.diff(
        Settings.builder().put("some.prefix.foo.somekey", 5).build(),
        Settings.builder().put("some.prefix.foobar.somekey", 17,
            "some.prefix.foo.somekey", 18).build());
    assertEquals(3, diff.size());
    assertThat(diff.getAsInt("some.prefix.foobar.somekey", null), equalTo(17));
    assertNull(diff.get("some.prefix.foo.somekey"));
    assertNull(diff.getAsArray("foo.bar.quux", null)); // affix settings don't know their concrete keys
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(1));
    assertThat(diff.getAsInt("foo.bar", null), equalTo(1));

    diff = settings.diff(
        Settings.builder().put("some.prefix.foo.somekey", 5).build(),
        Settings.builder().put("some.prefix.foobar.somekey", 17,
            "some.prefix.foo.somekey", 18)
        .putArray("foo.bar.quux", "x", "y", "z")
        .putArray("foo.baz.quux", "d", "e", "f")
            .build());
    assertEquals(9, diff.size());
    assertThat(diff.getAsInt("some.prefix.foobar.somekey", null), equalTo(17));
    assertNull(diff.get("some.prefix.foo.somekey"));
    assertArrayEquals(diff.getAsArray("foo.bar.quux", null), new String[] {"x", "y", "z"});
    assertArrayEquals(diff.getAsArray("foo.baz.quux", null), new String[] {"d", "e", "f"});
    assertThat(diff.getAsInt("foo.bar.baz", null), equalTo(1));
    assertThat(diff.getAsInt("foo.bar", null), equalTo(1));
}