});
            } else {
                job.launchNow();
            }
        }).orElse(() -> {
            throw new JobNotFoundException(this);
        });
    }

    public void stop() {
        ComponentUtil.getJobManager().findJobByUniqueOf(LaJobUnique.of(getId())).ifPresent(job -> {
            job.stopNow();
        }).orElse(() -> {
            throw new JobNotFoundException(this);
        });

        final ScheduledJob scheduledJob = createTestScheduledJob();
        final JobLog jobLog = new JobLog(scheduledJob);

        final String str = jobLog.toString();
        assertTrue(str.contains("Test Job"));
        assertTrue(str.contains(Constants.RUNNING));
    }

    private ScheduledJob createTestScheduledJob() {
        final ScheduledJob scheduledJob = new ScheduledJob();

						<div class="d-sm-none"></div>
						<span class="d-none d-sm-inline-block">&nbsp;</span>
						<a href="#${doc.doc_id}" class="favorite"><i class="far fa-star" aria-hidden="true"></i></a>
						<span class="favorited"><i class="fas fa-star" aria-hidden="true"></i></span>
					</c:if>
				</div>
			</li>
		</c:forEach>
	</ol>
	<aside class="col-md-4 d-none d-md-block">
		<%-- Side Content --%>

    @Test
    public void test_toString() {
        // Test toString method
        DictionaryExpiredException exception = new DictionaryExpiredException();
        String str = exception.toString();

        assertNotNull(str);
        assertTrue(str.contains("DictionaryExpiredException"));
    }

    @Test
    public void test_getLocalizedMessage() {
        // Test getLocalizedMessage method

        item.setNewOutput("newOutput");

        String str = item.toString();
        assertTrue(str.contains("id=1"));
        assertTrue(str.contains("inputs=[a, b]"));
        assertTrue(str.contains("output=output"));
        assertTrue(str.contains("newInputs=[x, y]"));
        assertTrue(str.contains("newOutput=newOutput"));
    }

    @Test

    }

    /**
     * Stores a protected words item (insert or update).
     * @param dictId the dictionary ID
     * @param protwordsItem the item to store
     */
    public void store(final String dictId, final ProtwordsItem protwordsItem) {
        getProtwordsFile(dictId).ifPresent(file -> {
            if (protwordsItem.getId() == 0) {
                file.insert(protwordsItem);

            throwValidationErrorApi(messages -> {
                messages.addErrorsCrudFailedToCreateInstance(GLOBAL);
            });
            return null;
        });
        try {
            roleService.store(entity);
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);

                errors << "Nullability breaking change"
            }

        } else if (member instanceof JApiConstructor) {

            JApiConstructor ctor = (JApiConstructor) member
            inspectParametersNullabilityOf(ctor.oldConstructor.get(), ctor.newConstructor.get())

        } else if (member instanceof JApiMethod) {

            JApiMethod method = (JApiMethod) member

        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;
        final WebConfig webConfig = getWebConfig(body).map(entity -> {
            try {
                webConfigService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);

        validate(form, messages -> {}, this::asEditHtml);
        verifyToken(this::asEditHtml);
        createStopwordsItem(form, this::asEditHtml).ifPresent(entity -> {
            stopwordsService.store(form.dictId, entity);
            saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
        }).orElse(() -> throwValidationError(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL), this::asEditHtml));