converterLookup = new DefaultConverterLookup();
        evaluator = mock(ExpressionEvaluator.class);
        listener = mock(ConfigurationListener.class);

        when(evaluator.evaluate(anyString())).thenReturn("testValue");
        for (int i = 0; i < 10; i++) {
            when(evaluator.evaluate(Integer.toString(i))).thenReturn(i);
        }
        when(evaluator.evaluate("123")).thenReturn(123);

        config.setValue("testValue");

        when(evaluator.evaluate("testValue")).thenReturn("testValue");

        helper.setProperty(bean, "name", String.class, config);

        assertEquals("testValue", bean.getName());
        verify(listener).notifyFieldChangeUsingSetter("name", "testValue", bean);
    }

    @Test
    void testSetPropertyWithField() throws Exception {

            // 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
            verify(mockBuffer).enc_ndr_short(testValue & 0xFF);
            verifyNoMoreInteractions(mockBuffer);
        }

        // Test the encode method
        long testValue = 987654321098765L;
        NdrHyper ndrHyper = new NdrHyper(testValue);

        // Call the encode method with the mocked NdrBuffer
        ndrHyper.encode(mockNdrBuffer);

        // Verify that enc_ndr_hyper was called exactly once with the correct value
        verify(mockNdrBuffer, times(1)).enc_ndr_hyper(testValue);
        verifyNoMoreInteractions(mockNdrBuffer);
    }

        int testValue = 98765;
        NdrLong ndrLong = new NdrLong(testValue);

        // Call the encode method
        ndrLong.encode(mockNdrBuffer);

        // Verify that enc_ndr_long was called exactly once with the correct value
        verify(mockNdrBuffer, times(1)).enc_ndr_long(testValue);
        // Verify that no other interactions occurred with the mock buffer

        };

        for (long testValue : testValues) {
            FileInternalInfo testInfo = new FileInternalInfo();
            byte[] buffer = new byte[8];
            SMBUtil.writeInt8(testValue, buffer, 0);

            int bytesDecoded = testInfo.decode(buffer, 0, buffer.length);
            assertEquals(8, bytesDecoded);
            assertEquals(testValue, testInfo.getIndexNumber());

        // Test various values
        long[] testValues = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 0x123456789ABCDEFL };

        for (long testValue : testValues) {
            // Create and encode
            FileEndOfFileInformation original = new FileEndOfFileInformation(testValue);
            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

    @BeforeEach
    void onSetup() {
        // MockitoAnnotations.openMocks(this);

        Map<String, String> envVarMap = new HashMap<>();
        envVarMap.put("testKey", "testValue");
        envVarMap.put("testSpecialCharactersKey", "<test&Value>");
        OperatingSystemUtils.setEnvVarSource(new TestEnvVarSource(envVarMap));
    }

    @Test
    void testBuildEmptyRequest() throws Exception {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MultimapValuesTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testValues() {
    List<V> expected = new ArrayList<>();
    for (Entry<K, V> entry : getSampleElements()) {
      expected.add(entry.getValue());
    }
    assertEqualIgnoringOrder(expected, multimap().values());
  }

  public void testRowKeySet() {
    assertEquals(ImmutableSet.of(), INSTANCE.rowKeySet());
  }

  public void testRowMap() {
    assertEquals(ImmutableMap.of(), INSTANCE.rowMap());
  }

  public void testValues() {
    assertTrue(INSTANCE.values().isEmpty());
  }