// is set.
func (c Config) getTargetKVS(subSys, target string, redactSecrets bool) KVS {
	store, ok := c[subSys]
	if !ok {
		return nil
	}

	// Lookup will succeed, because this function only works with valid subSys
	// values.
	resultKVS := make([]KV, 0, len(store[target]))
	hkvs := HelpSubSysMap[subSys]
	for _, kv := range store[target] {
		hkv, _ := hkvs.Lookup(kv.Key)

        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });
        stemmerOverrideService.store(body.dictId, entity);
        return asJson(
                new ApiResult.ApiUpdateResponse().id(String.valueOf(entity.getId())).created(true).status(ApiResult.Status.OK).result());
    }

    /**

 *
 * <p><b>Warning: joiner instances are always immutable</b>; a configuration method such as {@code
 * useForNull} has no effect on the instance it is invoked on! You must store and use the new joiner
 * instance returned by the method. This makes joiners thread-safe, and safe to store as {@code
 * static final} constants.
 *
 * {@snippet :
 * // Bad! Do not do this!
 * Joiner joiner = Joiner.on(',');
 * joiner.skipNulls(); // does nothing!

        kryo.register(Boolean.class);
        kryo.register(boolean[].class);
        kryo.register(Byte.class);
        kryo.register(byte[].class);
        kryo.register(Short.class);
        kryo.register(short[].class);
        kryo.register(Character.class);
        kryo.register(char[].class);

        // Common object types
        kryo.register(Object.class);
        kryo.register(Object[].class);

                .isPresent();
    }

    /**
     * Stores a job log entry in the database.
     *
     * @param jobLog the job log entry to store
     */
    public void store(final JobLog jobLog) {
        ComponentUtil.getComponent(JobLogBhv.class).insertOrUpdate(jobLog, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });
    }

    /**

        GsaConfigParser parser = new GsaConfigParser();
        String xmlWithFileUrls = "<?xml version=\"1.0\"?>" + "<eef><config><globalparams>"
                + "<start_urls>file:///test\nsmb://server/share</start_urls>" + "</globalparams></config></eef>";

        parser.parse(new InputSource(new StringReader(xmlWithFileUrls)));

        assertFalse(parser.getWebConfig().isPresent());

        }

        @ParameterizedTest
        @DisplayName("Rejects non-IPC$ URLs")
        @ValueSource(strings = { "smb://server/C$/foo", "smb://server/public/foo", "smb://server/share/path" })
        void rejectsNonIpcShare(String url) {
            // Arrange & Act & Assert
            MalformedURLException ex =

 * the same injector is immediately matched to this explicit binding, which means extensions
 * cannot override this binding. This is because the lookup is always short-circuited in this
 * specific situation (plain @Inject request, and plain explicit binding for the same type.)
 *
 * The simplest solution is to use a custom @Named here so it isn't bound under the plain key.

  Double generateDoubleObject() {
    return new Double(generateDouble());
  }

  @Generates
  short generateShort() {
    return (short) generateInt();
  }

  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
  @Generates
  Short generateShortObject() {
    return new Short(generateShort());
  }

  @Generates
  byte generateByte() {
    return (byte) generateInt();
  }

        }
    }

    @Nested
    @DisplayName("Test Implementation Tests")
    class TestImplementationTests {

        @Test
        @DisplayName("Should correctly store and return capacity")
        void shouldCorrectlyStoreAndReturnCapacity() {
            // Given
            long expectedCapacity = 1024L * 1024L * 1024L * 500L; // 500GB