}

        @Override
        public void decode_out(NdrBuffer _src) throws NdrException {
            level = _src.dec_ndr_long();
            _src.dec_ndr_long(); /* union discriminant */
            final int _infop = _src.dec_ndr_long();
            if (_infop != 0) {
                if (info == null) { /* YOYOYO */
                    info = new ShareInfoCtr0();
                }

                log.warn("Tree handle was not properly released, performing emergency cleanup: "
                        + (this.resourceLoc != null ? this.resourceLoc.getURL() : "unknown"));
                emergencyReleaseHandle();
            }
        } catch (Exception e) {
            log.error("Error during tree handle finalization", e);
        } finally {
            super.finalize();

            for (final String line : lines) {
                if (StringUtil.isNotBlank(line)) {
                    final int pos = line.indexOf('=');
                    if (pos == 0) {
                        paramMap.put("unknown." + (unknownKey + 1), line.substring(pos + 1).trim());
                        unknownKey++;
                    } else if (pos > 0) {
                        final String key = line.substring(0, pos).trim();

                    logger.debug("container was destroyed.");
                }
                return;
            }
            logger.warn("Failed to store failure url: url={}", urlQueue != null ? urlQueue.getUrl() : "unknown", e);
        }

        super.processCrawlingException(objs);
        if (urlQueue != null) {
            ComponentUtil.getCrawlerStatsHelper().record(urlQueue, StatsAction.ACCESS_EXCEPTION);
        }
    }

    }

    @DisplayName("Should parse different share types correctly")
    @ParameterizedTest
    @CsvSource({ "1, 1", // DISK
            "2, 2", // PIPE
            "3, 3", // PRINT
            "0, 0", // Unknown
            "255, -1" // Byte overflow to signed
    })
    void testDifferentShareTypes(int shareTypeValue, int expectedValue) throws SMBProtocolDecodingException {
        // Given

            this.algorithmName = "AESCMAC";
            this.provider = Crypto.getProvider();
            break;
        default:
            throw new IllegalArgumentException("Unknown dialect");
        }

        // Initialize the digest once to validate configuration
        this.digest = createMacInstance();
    }

    /**
     * Create a new Mac instance for thread-safe operations

        }

        @Test
        @DisplayName("Should throw exception for unknown dialect")
        void testConstructorUnknownDialect() {
            IllegalArgumentException exception =
                    assertThrows(IllegalArgumentException.class, () -> new Smb2SigningDigest(sessionKey, 0x9999, null));
            assertEquals("Unknown dialect", exception.getMessage());
        }

        @ParameterizedTest

                return message.contains("retry") || message.contains("temporary") || message.contains("timeout")
                        || message.contains("connection");
            }
            return false; // Unknown IO errors are likely not recoverable
        }

        // Runtime exceptions and other errors are likely not recoverable
        return false;
    }

    /**

                        logger.debug("No thumbnail: {} -> {}", thumbnailId, responseData.getUrl());
                    }
                    break;
                default:
                    logger.error("Unknown thumbnail result: {} -> {}", thumbnailId, responseData.getUrl());
                    break;
                }
            } catch (final Throwable t) {

	typedef struct {
		uint32_t flags;
		[string] wchar_t *dfs_name;
	} DfsInfo300;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo300 *s;
	} DfsEnumArray300;

	typedef union {
		[case(1)] DfsEnumArray1 *info1;
		[case(3)] DfsEnumArray3 *info3;
		[case(200)] DfsEnumArray200 *info200;
		[case(300)] DfsEnumArray300 *info300;
	} DfsEnumInfo;

	typedef struct {
		uint32_t level,