/** Default logon share */
    protected String logonShare;
    /** Default domain for authentication */
    protected String defaultDomain;
    /** Default username for authentication */
    protected String defaultUserName;
    /** Default password for authentication */
    protected String defaultPassword;
    /** NetBIOS hostname */
    protected String netbiosHostname;
    /** NetBIOS name cache policy in seconds */

        }
        final String url = DocumentUtil.getValue(doc, fessConfig.getIndexFieldUrl(), String.class);
        if (url == null) {
            saveError(messages -> messages.addErrorsDocumentNotFound(GLOBAL, form.docId));
            return redirect(ErrorAction.class);
        }

        if (fessConfig.isSearchLog()) {
            final String userSessionId = userInfoHelper.getUserCode();

}

func storageTrace(s storageMetric, startTime time.Time, duration time.Duration, path string, size int64, err string, custom map[string]string) madmin.TraceInfo {
	return madmin.TraceInfo{
		TraceType: madmin.TraceStorage,
		Time:      startTime,
		NodeName:  globalLocalNodeName,
		FuncName:  "storage." + s.String(),
		Duration:  duration,
		Bytes:     size,
		Path:      path,
		Error:     err,

    @Override
    public String asTableDbName() {
        return asEsIndexType();
    }

    @Override
    protected String asEsIndex() {
        return "fess_config.web_authentication";
    }

    @Override
    public String asEsIndexType() {
        return "web_authentication";
    }

    @Override
    public String asEsSearchType() {
        return "web_authentication";
    }

        assertNotNull(cifsContextWrapper);
    }

    @Test
    void testGetSmbResource() throws CIFSException, MalformedURLException {
        // Test get(String url) method
        String url = "smb://server/share/file.txt";
        SmbResource mockSmbResource = mock(SmbFile.class);
        // Mocking SmbFile constructor is tricky, so we'll just verify the call to the delegate

     *            the object to convert
     * @param pattern
     *            the pattern string
     * @return the converted {@link Long}
     */
    public static Long toLong(final Object o, final String pattern) {
        return switch (o) {
        case null -> null;
        case Long l -> l;
        case Number n -> n.longValue();
        case String s -> toLong(s);

	type (
		Preload struct {
			ID       uint
			Value    string
			NestedID uint
		}
		Join struct {
			ID       uint
			Value    string
			NestedID uint
		}
		Nested struct {
			ID       uint
			Preloads []*Preload
			Join     Join
			ValueID  uint
		}
		Value struct {
			ID     uint
			Name   string
			Nested Nested
		}
	)

   * and returns {@code null} if non-ASCII digits are present in the string.
   *
   * <p>Note that strings prefixed with ASCII {@code '+'} are rejected, even though {@link
   * Integer#parseInt(String)} accepts them.
   *
   * @param string the string representation of an integer value
   * @return the integer value represented by {@code string}, or {@code null} if {@code string} has
   *     a length of zero or cannot be parsed as an integer value

        final String scoreField = fessConfig.getRankFusionScoreField();
        final Map<String, Map<String, Object>> scoreDocMap = new HashMap<>();
        final String idField = fessConfig.getIndexFieldId();
        final Set<Object> mainIdSet = new HashSet<>();
        for (int i = 0; i < results.length; i++) {
            final List<Map<String, Object>> docList = results[i].getDocumentList();

        private final String nodeName;
        private final Map<String, MockNode> attributes = new HashMap<>();
        private final MockNamedNodeMap namedNodeMap = new MockNamedNodeMap();

        public MockNode(String nodeName) {
            this.nodeName = nodeName;
        }

        public void addAttribute(String name, String value) {
            MockNode attrNode = new MockNode(name);