Parameter param = params.get(i);
      if (i != indexOfParamToSetToNull) {
        args[i] = getDefaultValue(param.getType());
        Assert.assertTrue(
            "Can't find or create a sample instance for type '"
                + param.getType()
                + "'; please provide one using NullPointerTester.setDefault()",
            args[i] != null || isNullable(param));
      }
    }

    ImmutableList<Parameter> parameters = delegate.getParameters();
    assertEquals(2, parameters.size());
    assertEquals(String.class, parameters.get(0).getType().getType());
    assertTrue(parameters.get(0).isAnnotationPresent(NotBlank.class));
    assertEquals(int.class, parameters.get(1).getType().getType());
    assertFalse(parameters.get(1).isAnnotationPresent(NotBlank.class));
    new EqualsTester()
        .addEqualityGroup(parameters.get(0))

    void testConstructor_NonWorkgroupType_ThrowsException() throws Exception {
        // Given: A non-workgroup type with a host
        when(locator.getType()).thenReturn(SmbConstants.TYPE_SERVER);
        when(locator.getURL()).thenReturn(createSmbURL("smb://server/"));

        // When & Then: Constructor should throw SmbException

        // Test with hidden flag (0x80000000) which should be ignored by getType()
        SmbShareInfo hiddenPrinter = new SmbShareInfo("HIDDEN_PRINTER", 1 | 0x80000000, "hidden printer");
        assertEquals(SmbFile.TYPE_PRINTER, hiddenPrinter.getType());
    }

    /**
     * Test of getAttributes method, of class SmbShareInfo.
     */
    @Test
    void testGetAttributes() {

        assertEquals(int.class, ServerData.class.getDeclaredField("sflags2").getType());
        assertEquals(int.class, ServerData.class.getDeclaredField("smaxMpxCount").getType());
        assertEquals(int.class, ServerData.class.getDeclaredField("maxBufferSize").getType());
        assertEquals(int.class, ServerData.class.getDeclaredField("sessKey").getType());

        }
    }

    @ParameterizedTest(name = "getType returns {0}")
    @ValueSource(ints = { 0, 1, -5, Integer.MAX_VALUE })
    @DisplayName("Parameterized type values")
    void typeParameterized(int type) {
        FileEntry mock = mock(FileEntry.class);
        when(mock.getType()).thenReturn(type);
        assertEquals(type, mock.getType());
    }

    @Test

    void testGetTypeWithDifferentShareTypes(int inputType, int expectedType) {
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, inputType, TEST_REMARK);
        assertEquals(expectedType, info.getType());
    }

    @Test
    @DisplayName("Test getType with hidden flag")
    void testGetTypeWithHiddenFlag() {
        // Hidden flag (0x80000000) should be masked out
        int hiddenPrinterType = 0x80000001; // Hidden printer

    static Stream<Arguments> intGetterProvider() {
        return Stream.of(Arguments.of((IntGetter) FileEntry::getType, -1, "negative type"),
                Arguments.of((IntGetter) FileEntry::getType, 0, "zero type"),
                Arguments.of((IntGetter) FileEntry::getType, Integer.MAX_VALUE, "max type"),

                Arguments.of((IntGetter) FileEntry::getAttributes, 0, "no attributes"),

                if (lastItem.isNull()) {
                    if (i == size() - 1 || get(i + 1).getType() == STRING_ITEM) {
                        remove(i);
                    } else if (get(i + 1).getType() == LIST_ITEM) {
                        Item item = ((ListItem) get(i + 1)).get(0);
                        if (item.getType() == COMBINATION_ITEM || item.getType() == STRING_ITEM) {
                            remove(i);
                        }

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

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