// When/Then: Should throw SmbException
        SmbException ex = assertThrows(SmbException.class, () -> poolSpy.getChallenge(ctx, address));
        assertTrue(ex.getMessage().contains("Connection failed"));
    }

    @Test
    @DisplayName("Should perform logon to IPC$ share")
    void testLogon() throws Exception {

        verify(transport, times(1)).release();
        assertFalse(session.isInUse());

        // Next release goes below zero and throws
        RuntimeException ex = assertThrows(RuntimeCIFSException.class, session::release);
        assertTrue(ex.getMessage().contains("below zero"));

        // Only one transport release should have occurred
        verify(transport, times(1)).release();
    }

    @Test

                            }
                        }
                    }
                } catch (Exception e) {
                    // here we can have: IO. ZIP or Plexus Conf Ex: but we should not interfere with user intent
                }
            }
        }
        return null;
    }

    private static String mayGetChild(XmlNode node, String child) {

    @Test
    @DisplayName("DFS referrals: invalid double-slash prefix triggers exception")
    void dfsReferrals_invalidPath() {
        CIFSException ex = assertThrows(CIFSException.class, () -> transport.getDfsReferrals(ctx, "\\\\server\\share", null, null, 1));
        assertTrue(ex.getMessage().contains("double slash"));
    }

    @Nested
    @MockitoSettings(strictness = Strictness.LENIENT)
    class PreauthHashAndEncryption {

                        return;
                    }

                    this.out.write(this.b, 0, this.n);
                }
            } catch (final SmbException ex) {
                this.e = ex;
            } catch (final Exception x) {
                this.e = new SmbException("WriterThread", x);
            }
            notify();
        }
    }

const (
	offline = iota
	online
	closed
)

// NetworkError - error type in case of errors related to http/transport
// for ex. connection refused, connection reset, dns resolution failure etc.
// All errors returned by storage-rest-server (ex errFileNotFound, errDiskNotFound) are not considered to be network errors.
type NetworkError struct {
	Err error
}

func (n *NetworkError) Error() string {

	</component>
	<component name="crawlingInfoHelper" class="org.codelibs.fess.helper.CrawlingInfoHelper">
	</component>
	<component name="roleQueryHelper" class="org.codelibs.fess.helper.RoleQueryHelper">
		<!-- ex. parameter: fessRoles=123%0aRadmin -->
		<!-- 
		<property name="parameterKey">"fessRoles"</property>
		<property name="encryptedParameterValue">false</property>
		<property name="headerKey">"fessRoles"</property>

  - Edit the application
    - Copy `Client ID` and `Client secret`
    - Add your redirect url (callback url) to `Redirect URLs`
    - Save

- Go to Users
  - Edit the user
    - Add your MinIO policy (ex: `readwrite`) in `Tag`
    - Save

- Open your favorite browser and visit: **http://`CASDOOR_ENDPOINT`/.well-known/openid-configuration**, you will see the OIDC configure of Casdoor.

### Configure MinIO

```

                ans = NbtAddress.getByName(host, type, scope, svr);
            } catch (final UnknownHostException uhe) {
                this.uhe = uhe;
            } catch (final Exception ex) {
                this.uhe = new UnknownHostException(ex.getMessage());
            } finally {
                synchronized (sem) {
                    sem.count--;
                    sem.notify();
                }
            }

        final InputStream is = getResourceAsStream(path);
        try {
            props.load(is);
            return props;
        } catch (final IOException ex) {
            throw new IORuntimeException(ex);
        } finally {
            CloseableUtil.close(is);
        }
    }

    /**
     * Returns the extension of the path.
     *
     * @param path