}
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException e) {
            assertEquals("Simulated processing error", e.getMessage());
            // If InputStream wasn't properly closed, this would leak resources
            // try-with-resources ensures cleanup happens
        } catch (IOException e) {
            fail("Should not throw IOException: " + e.getMessage());
        }

        try {
            file = File.createTempFile("script", extention);
            file.deleteOnExit();
            FileUtil.writeBytes(file.getAbsolutePath(), content.getBytes());
            return file;
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    private File createScriptTempFileStdout(final int sleep) {
        String extention;
        String content;

    Thread waiter =
        new Thread() {
          @Override
          public void run() {
            try {
              service.awaitTermination(1, DAYS);
            } catch (InterruptedException e) {
              return;
            }
          }
        };
    waiter.start();
    awaitTimedWaiting(waiter);
    service.shutdown();

                renderData.register(data);
            });
        } catch (final InvalidQueryException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid query: {}", form.q, e);
            }
            throwValidationError(e.getMessageCode(), this::asListHtml);
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {

      fail(message);
    } catch (UnsupportedOperationException expected) {
    }
  }

  private void expectReturnsFalseOrThrows(Target target) {
    String message = Platform.format("retainAll(%s) should return false or throw", target);
    try {
      assertFalse(message, collection.retainAll(target.toRetain));
    } catch (UnsupportedOperationException tolerated) {
    }
  }

        assert response.json() == snapshot(
            [{"name": "Spider-Boy", "age": 18, "id": IsInt()}]
        )

        # Update a hero
        response = client.patch(
            f"/heroes/{hero_id}", json={"name": "Dog Pond", "age": None}
        )
        assert response.status_code == 200, response.text
        assert response.json() == snapshot(

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

        Enumeration<?> fields = sequence.getObjects();
        while (fields.hasMoreElements()) {

        } catch (final JobProcessingException e) {
            // Rethrow JobProcessingException to allow scripts to signal job-specific errors
            // that should be handled by the job framework
            if (logger.isDebugEnabled()) {
                logger.debug("Script raised JobProcessingException", e);
            }
            throw e;
        } catch (final Exception e) {

        if (!Constants.T.equals(scheduledJob.getAvailable())) {
            logger.info("Inactive Job: id={}, name={}", id, scheduledJob.getName());
            try {
                unregister(scheduledJob);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to delete Job: job={}", scheduledJob, e);
                }
            }
            return;
        }

                    } catch (NoSuchFieldException e) {
                        clazz = clazz.getSuperclass();
                    }
                }
                if (field == null) {
                    throw new NoSuchFieldException(fieldName);
                }
                field.setAccessible(true);
                field.set(this, value);
            } catch (Exception e) {