// When/Then: Should throw exception
            NdrException thrown = assertThrows(NdrException.class, () -> entry.decode(mockNdrBuffer));
            assertEquals(NdrException.INVALID_CONFORMANCE, thrown.getMessage());
        }
    }

    @Nested
    @DisplayName("SamrSamArray Tests")
    class SamrSamArrayTests {

        @Test
        @DisplayName("Should encode array with entries")

            pw.flush();
            return systemHelper.abbreviateLongText(sw.toString());
        } catch (final IOException e) {
            logger.warn("Failed to print the stack trace {}", t.getMessage(), e);
        }
        return StringUtil.EMPTY;
    }

            // If no exception thrown, test passes
            assertTrue(true);
        } catch (Exception e) {
            fail("initializeProbes should not throw exception: " + e.getMessage());
        }
    }

    public void test_main_withHelp() {
        // Test main method with help option
        PrintStream originalErr = System.err;
        try {

            queryCommand.execute(queryContext, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    public void test_toLowercaseWildcard_enabled() {
        queryCommand.setLowercaseWildcard(true);

            der.writeObject(derApplicationSpecific);
            return collector.toByteArray();
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    protected void parse(final byte[] token) throws IOException {

        try (ASN1InputStream is = new ASN1InputStream(token)) {

                            Thread.sleep(1);
                            session.release();
                        }
                    }
                } catch (Exception e) {
                    if (!e.getMessage().contains("Usage count dropped below zero")) {
                        exceptions.add(e);
                    }
                } finally {
                    endLatch.countDown();
                }

                        "Should throw SMBProtocolDecodingException for invalid structure size");

        assertEquals("Expected structureSize = 9", exception.getMessage());
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 100, 255, 256, 65535 })
    @DisplayName("Test readBytesWireFormat with various invalid structure sizes")

                    return true;
                }
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Silent token refresh failed: {}", e.getMessage());
                }
            }
            // For MSAL4J, if silent refresh fails, return true if token is still valid
            // Actual refresh will happen during next authentication request

            der.writeObject(new DERTaggedObject(true, 1, new DERSequence(fields)));
            return collector.toByteArray();
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    protected void parse(final byte[] token) throws IOException {
        try (ASN1InputStream der = new ASN1InputStream(token)) {

        try {
            thumbnailJob.executeThumbnailGenerator();
            fail("Should throw JobProcessingException");
        } catch (JobProcessingException e) {
            assertTrue(e.getMessage().contains("Thumbnail Process terminated."));
        } catch (NullPointerException e) {
            // May occur if ServletContext is not fully initialized
            // This is acceptable in test environment
        }