}
                jobLog.setScriptResult(ret.toString());
            }
            jobLog.setJobStatus(Constants.OK);
        } catch (final Throwable t) {
            logger.warn("Failed to execute job: id={}, script={}", id, script, t);
            jobLog.setJobStatus(Constants.FAIL);

                            .stdErr(stdErr)
                            .embedded(embedded)
                            .build()));
        } catch (InvokerException.ExitException e) {
            return e.getExitCode();
        } catch (Exception e) {
            // last resort; as ideally we should get ExitException only
            new SystemLogger(stdErr).error(e.getMessage(), e);
            return 1;

                fos.write(chunk);
            }
        }

        try {
            FileUtil.readBytes(largeFile);
            fail("Expected IORuntimeException for large file");
        } catch (final IORuntimeException e) {
            assertTrue("Error message should mention file size", e.getMessage().contains("File too large"));
        }
    }

    /**
     * Test readBytes with file within size limit

            }
            stream.close();
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos ticket", e);
        }

        ASN1Sequence sequence;
        try {
            sequence = ASN1Util.as(ASN1Sequence.class, derToken.getBaseObject());
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos ticket", e);

                int compressedSize = deflater.deflate(buffer);
                baos.write(buffer, 0, compressedSize);
            }

            deflater.end();
            return baos.toByteArray();
        } catch (Exception e) {
            throw new CIFSException("LZ77 compression failed", e);
        }
    }

    /**
     * Decompresses LZ77 data.
     */

                try {
                    projectExtension.verifyTestFilesCleanup(projectPath, projectPathToLeftoverFiles.getValue(projectPath))
                } catch (e: Exception) {
                    exceptions.add(e)
                }
            }
        when {
            exceptions.size == 1 -> throw exceptions.first()

        body.crudMode = CrudMode.CREATE;
        final DuplicateHost duplicateHost = getDuplicateHost(body).map(entity -> {
            try {
                duplicateHostService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));

                    try {
                      AbstractExecutionThreadService.this.run();
                    } catch (Throwable t) {
                      restoreInterruptIfIsInterruptedException(t);
                      try {
                        shutDown();
                      } catch (Exception ignored) {
                        restoreInterruptIfIsInterruptedException(ignored);

                    ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN,
                    true);
        } catch (org.apache.maven.wagon.TransferFailedException e) {
            throw new ArtifactTransferFailedException(getMessage(e, "Error transferring artifact."), e);
        } catch (org.apache.maven.wagon.ResourceDoesNotExistException e) {

        return kuromojiService.getKuromojiFile(form.dictId).map(file -> {
            try (InputStream inputStream = form.kuromojiFile.getInputStream()) {
                file.update(inputStream);
            } catch (final IOException e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsFailedToUploadKuromojiFile(GLOBAL),