* @param offset starting offset
     * @return decoded response
     */
    public static SmbDirectNegotiateResponse decode(byte[] data, int offset) {
        if (data.length - offset < 32) {
            throw new IllegalArgumentException("Invalid SMB Direct Negotiate Response length");
        }

        SmbDirectNegotiateResponse response = new SmbDirectNegotiateResponse();

        int idx = offset;

    public static ChangelogEntry parse(File file) {
        try {
            return yamlMapper.readValue(file, ChangelogEntry.class);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    public Integer getPr() {
        return pr;
    }

    public void setPr(Integer pr) {
        this.pr = pr;
    }

                badWordService.importCsv(reader);
                suggestHelper.storeAllBadWords(false);
            } catch (final Exception e) {
                throw new FessSystemException("Failed to import data.", e);
            }
        });
        return asJson(new ApiResult.ApiResponse().status(ApiResult.Status.OK).result());
    }

    /**

        callback.store(params, data);
        callback.store(params, data);

        assertEquals(3L, callback.getDocumentSize());
        assertEquals(300L, callback.getExecuteTime());

        // Test commit (should not throw exception)
        callback.commit();
    }

    @Test
    public void test_multiple_implementations() {
        // Test with different implementations to ensure interface contract

  public abstract ImmutableBiMap<V, K> inverse();

  @Override
  public ImmutableSet<V> values() {
    return inverse().keySet();
  }

  public final @Nullable V forcePut(K key, V value) {
    throw new UnsupportedOperationException();
  }

            // Check if transport creation failed
            if (newTransport == null) {
                throw new IOException("Failed to create new transport");
            }

            // Reconnect
            channel.setState(ChannelState.CONNECTING);

        assertEquals(64, newHash.length); // SHA-512 produces 64 bytes
        assertNotEquals(oldHash, newHash); // Should be different instance
    }

    /**
     * Test pre-auth integrity with non-SMB3.1.1 should throw exception
     */
    @Test
    @DisplayName("Pre-auth integrity should fail with non-SMB3.1.1")
    void testPreauthWithNonSmb311() throws Exception {
        // Setup SMB3.0

        // Test engineDigest with buffer too small
        HMACT64 hmac = new HMACT64(TEST_KEY);
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);

        byte[] buffer = new byte[10];
        // Should throw exception when buffer is too small
        assertThrows(IllegalStateException.class, () -> hmac.engineDigest(buffer, 0, 10));
    }

    @Test
    void testClone() {
        // Test clone() method

        artifact.setFile(localFile);

        if (!localFile.exists()) {
            if (request.getRemoteRepositories().isEmpty()) {
                throw new IOException(localFile + " does not exist and no remote repositories are configured");
            }

            ArtifactRepository remoteRepo = request.getRemoteRepositories().get(0);

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

    protected <RESULT extends CrawlingInfo> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;
    }