}
                        }
                    }
                } 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) {

                            transport.ensureConnected();
                            return transport;
                        } catch (final IOException ex) {
                            log.debug("Connection failed " + dr.getServer(), ex);
                            e = ex;
                            dr = dr.next();
                            continue;
                        }
                    }

    try {
      Shorts.checkedCast(value);
      fail("Cast to short should have failed: " + value);
    } catch (IllegalArgumentException ex) {
      assertWithMessage("%s not found in exception text: %s", value, ex.getMessage())
          .that(ex.getMessage().contains(String.valueOf(value)))
          .isTrue();
    }
  }

  // We need to test that our method behaves like the JDK method.

        when(nsc.getAllByName("badhost", true)).thenThrow(new UnknownHostException("nope"));
        SmbResourceLocatorImpl bad = locator("smb://badhost/");
        CIFSException ex = assertThrows(CIFSException.class, bad::getAddress);
        assertTrue(ex.getMessage().contains("Failed to lookup address"));
    }

    @Test
    @DisplayName("hashCode/equals based on address or server fallback")

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 {

            this.defaultDomain = p.getProperty("jcifs.smb.client.domain");
            this.transportContext = new BaseContext(new PropertyConfiguration(p));
        } catch (final CIFSException ex) {
            throw new ServletException("Failed to initialize CIFS context", ex);
        }
    }

    /**
     * Handles file download requests for SMB files.
     * @param req the HTTP servlet request
     * @param resp the HTTP servlet response

        encoding = config.getInitParameter(LastaPrepareFilter.ENCODING_KEY);
        if (encoding == null) {
            encoding = LastaPrepareFilter.DEFAULT_ENCODING;
        }

        // ex. sjis:Shift_JIS,eucjp:EUC-JP
        final String value = config.getInitParameter(ENCODING_MAP);
        if (StringUtil.isNotBlank(value)) {
            final String[] encodingPairs = value.split(",");

Le bon endroit est :

* Dans la clé `content`, qui a pour valeur un autre objet JSON (`dict`) qui contient :
    * Une clé avec le type de support, par ex. `application/json`, qui contient comme valeur un autre objet JSON, qui contient :
        * Une clé `schema`, qui a pour valeur le schéma JSON du modèle, voici le bon endroit.

    - This value is needed for `MINIO_IDENTITY_OPENID_CLIENT_SECRET` for MinIO.

- Go to Users
  - Click on the user
  - Attribute, add a new attribute `Key` is `policy`, `Value` is name of the `policy` on MinIO (ex: `readwrite`)
  - Add and Save

- Go to Clients
  - Click on `account`
  - Settings, set `Valid Redirect URIs` to `*`, expand `Advanced Settings` and set `Access Token Lifespan` to `1 Hours`
  - Save

variables from your model are also going to be untrusted. That means that if
your code interacts with the filesystem, network, etc. and uses checkpointed
variables as part of those interactions (ex: using a string variable to build a
filesystem path), a maliciously created checkpoint might be able to change the
targets of those operations, which could result in arbitrary
read/write/executions.