@Test
        void notEqualWhenOidDiffersOrNameNullityDiffers() {
            MIEName a = new MIEName(new ASN1ObjectIdentifier("1.2.3"), "X");
            MIEName b = new MIEName(new ASN1ObjectIdentifier("1.2.4"), "X");
            MIEName c = new MIEName(new ASN1ObjectIdentifier("1.2.3"), null);
            assertNotEquals(a, b);
            assertNotEquals(a, c);
            assertNotEquals(a, new Object());
        }

                return testWindowSize;
            }
        });

        Map<String, Object> params = new HashMap<>();
        params.put("param1", "value1");
        params.put("param2", 123);

        RescorerBuilder<?> result = ltrQueryRescorer.evaluate(params);
        assertNotNull(result);
        assertTrue(result instanceof QueryRescorerBuilder);

    private static Stream<Arguments> valueProvider() {
        return Stream.of(Arguments.of(0, 0L, 0L, 0L, 0L), // all zeros
                Arguments.of(1, 1L, 1L, 1L, 1L), // ones
                Arguments.of(123, 456L, 789L, 101112L, 131415L), // arbitrary positives
                Arguments.of(Integer.MAX_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, 999_999_999_999L, -1L), // extremes

            file.deleteOnExit();
            fileTransformer.setPath(file.getAbsolutePath());
            crawler.setBackground(true);
            ((UrlFilterImpl) crawler.urlFilter).setIncludeFilteringPattern("$1$2$3.*");
            crawler.addUrl(url);
            crawler.getCrawlerContext().setMaxAccessCount(maxCount);
            crawler.getCrawlerContext().setNumOfThread(numOfThread);

    }

    @Test
    @DisplayName("toString with special characters in pipe name")
    void testToStringWithSpecialCharacters() {
        // Arrange
        String specialPipeName = "\\PIPE\\test$pipe#123";
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, specialPipeName);

        // Act
        String result = transWaitNamedPipe.toString();

        // Assert
        assertNotNull(result);

   0 1 2 3 4 5 6 7    0 1 2 3 4 5 6 7
  +-+-+-+-+-------+  +-+-------------+
  |F|R|R|R| OP    |  |M| LENGTH      |
  |I|S|S|S| CODE  |  |A|             |
  |N|V|V|V|       |  |S|             |
  | |1|2|3|       |  |K|             |
  +-+-+-+-+-------+  +-+-------------+
   */

  /** Byte 0 flag for whether this is the final fragment in a message. */
  internal const val B0_FLAG_FIN = 128

    runConcurrentlyMutatedTest(elements(1, 2), ops(remove(), add(3)), wrap);

    runConcurrentlyMutatedTest(elements(1, 2), ops(nop(), remove()), wrap);

    runConcurrentlyMutatedTest(elements(1, 2, 3), ops(remove(), remove()), wrap);
  }

  private static ImmutableList<Integer> elements(Integer... elements) {
    return ImmutableList.copyOf(elements);
  }

    class EncodingTests {

        @Test
        @DisplayName("Should encode value correctly")
        void testEncode() throws NdrException {
            // Given: NdrShort with test value
            int testValue = 123;
            NdrShort ndrShort = new NdrShort(testValue);

            // When: Encoding the value
            ndrShort.encode(mockBuffer);

            // Then: Should call enc_ndr_short with masked value

        assertSame(second, retrieved2);
    }

    public void test_multiple_components() {
        String comp1 = "component1";
        String comp2 = "component2";
        Integer comp3 = 123;

        ComponentUtil.register(comp1, "name1");
        ComponentUtil.register(comp2, "name2");
        ComponentUtil.register(comp3, "name3");

        assertEquals(comp1, ComponentUtil.getComponent("name1"));

        assertProvideThrowsException("Test\nClassification");
    }

    public void test_provide_withNumericValues() {
        // Test classification names with numeric values
        assertProvideThrowsException("123");
        assertProvideThrowsException("0");
        assertProvideThrowsException("-1");
        assertProvideThrowsException("Test123");
        assertProvideThrowsException("123Test");