if (info.getType() == HandleType.PERSISTENT && !info.isReconnecting()) {
                    persistHandle(info);
                }
            }
        } finally {
            lock.writeLock().unlock();
        }
    }

    private void persistHandle(HandleInfo info) {
        if (info.getType() != HandleType.PERSISTENT) {
            return;
        }

        rawData[17] = 0x02;

        AvSingleHost avSingleHost = new AvSingleHost(rawData);

        assertNotNull(avSingleHost);
        assertEquals(AvPair.MsvAvSingleHost, avSingleHost.getType());
        assertArrayEquals(rawData, avSingleHost.getRaw());
    }

    /**
     * Test constructor AvSingleHost(Configuration cfg).
     * Should use the machine ID from the configuration.
     */
    @Test

        SMBUtil.writeInt8(1234567890L, rawBytes, 0); // Example timestamp
        AvTimestamp avTimestamp = new AvTimestamp(rawBytes);

        assertNotNull(avTimestamp);
        assertEquals(AvPair.MsvAvTimestamp, avTimestamp.getType());
        assertArrayEquals(rawBytes, avTimestamp.getRaw());
    }

    /**
     * Test constructor with long timestamp.
     */
    @Test
    public void testConstructorWithLongTimestamp() {

        this(
                message,
                artifact.getGroupId(),
                artifact.getArtifactId(),
                artifact.getVersion(),
                artifact.getType(),
                artifact.getClassifier(),
                null,
                artifact.getDownloadUrl(),
                artifact.getDependencyTrail());
    }

    protected ArtifactNotFoundException(

        byte[] testHash = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        AvChannelBindings avChannelBindings = new AvChannelBindings(testHash);

        assertEquals(AvPair.MsvAvChannelBindings, avChannelBindings.getType(), "Type should be MsvAvChannelBindings");
        assertArrayEquals(testHash, avChannelBindings.getRaw(), "Value should match the provided hash");
    }

    /**

            log.trace(String.format("Checksum data %s type %d signature %s", Hexdump.toHexString(checksumData),
                    this.serverSignature.getType(), Hexdump.toHexString(this.serverSignature.getChecksum())));
        }

        byte checksum[] = PacMac.calculateMac(this.serverSignature.getType(), keys, checksumData);
        if (!MessageDigest.isEqual(this.serverSignature.getChecksum(), checksum)) {
            if (log.isDebugEnabled()) {

        // Create PacSignature
        PacSignature pacSignature = new PacSignature(data);

        // Verify
        assertEquals(PacSignature.KERB_CHECKSUM_HMAC_MD5, pacSignature.getType());
        assertArrayEquals(checksum, pacSignature.getChecksum());
    }

    /**
     * Test constructor with HMAC_SHA1_96_AES128 type.
     *
     * @throws IOException if an I/O error occurs

        for (Field field : fields) {
            int modifiers = field.getModifiers();
            if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers)) {
                if (field.getType().equals(HtmlNext.class)) {
                    Object value = field.get(null);
                    assertNotNull(value, "Field " + field.getName() + " should not be null");

        seglistitem.appendChild(seg);
        if (blockDoc.isMultiValued()) {
            seg.appendChild(document.createTextNode("Each "));
            seg.appendChild(linkRenderer.link(blockDoc.getType(), listener));
            seg.appendChild(document.createTextNode(" in "));
            // TODO - add linkRenderer.link(property)
            Element link = document.createElement("link");
            seg.appendChild(link);

        DefaultToolchain toolchain = newDefaultToolchain(model, "TYPE");
        assertEquals("TYPE", toolchain.getType());

        model.setType("MODEL_TYPE");
        toolchain = newDefaultToolchain(model);
        assertEquals("MODEL_TYPE", toolchain.getType());
    }

    @Test
    void testGetLogger() {
        ToolchainModel model = new ToolchainModel();