nullawayEnabled.convention(false)
}

nullaway {
    // NullAway can use NullMarked instead, but for the adoption process it is more effective to assume that all gradle code is already annotated.
    // This way we can catch discrepancies in modules easier. We should make all packages NullMarked eventually too, but this is a separate task.
    annotatedPackages.add("org.gradle")
}

dependencies {
    attributesSchema {

                                writer.write(hit.getSourceAsString());
                                writer.write("\n");
                            } catch (final IOException e) {
                                throw new IORuntimeException(e);
                            }
                            return true;
                        });

            result.setUpdatedTime(DfTypeUtil.toLong(source.get("updatedTime")));
            result.setVirtualHosts(toStringArray(source.get("virtualHosts")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

            result.setValue(DfTypeUtil.toString(source.get("value")));
            result.setVirtualHost(DfTypeUtil.toString(source.get("virtualHost")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

        mockBhv.setTestData(testData);

        relatedQueryHelper.update();
        // Give a moment for async execution
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // ignore
        }

        results = relatedQueryHelper.getRelatedQueries("test");
        assertEquals("updated", results[0]);
    }

    @Test

        assertEquals("", DocumentUtil.encodeUrl(""));
        try {
            DocumentUtil.encodeUrl(null);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // Expected
        }
    }

    @Test
    public void test_encodeUrl_unicode() {
        assertEquals("%3F", DocumentUtil.encodeUrl("あ"));

    protected byte[] decodeBase64(String base64String) {
        if (base64String == null) {
            return null;
        }
        try {
            return BASE64_DECODER.decode(base64String);
        } catch (IllegalArgumentException e) {
            if (e.getCause() instanceof DecodingException) {
                return BASE64URL_DECODER.decode(base64String.trim());
            }
            throw e;
        }
    }

                    propField.setAccessible(true);
                    propField.set(this, new org.dbflute.helper.jprop.ObjectiveProperties("test"));
                } catch (Exception e) {
                    throw new RuntimeException("Failed to initialize prop field", e);
                }
            }

            @Override
            public String getIndexFieldTitle() {

                } else if (logger.isDebugEnabled()) {
                    logger.debug("No KeyMatch boost docs");
                }

                waitForNext();
            } catch (final Exception e) {
                logger.warn("Failed to load KeyMatch: id={}, term={}", keyMatch.getId(), keyMatch.getTerm(), e);
            }
        });
        this.keyMatchQueryMap = keyMatchQueryMap;

            return null;
        });
        try (InputStream inputStream = form.stemmerOverrideFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }