if (webinfPath != null && Files.exists(Paths.get(webinfPath))) {
                return Paths.get(webinfPath, names);
            }
        } catch (final Throwable e) {
            // ignore
        }
        final String webinfBase = root + base;
        if (Files.exists(Paths.get(webinfBase))) {
            return Paths.get(webinfBase, names);
        }

    K unmappedKey;
    try {
      map = makePopulatedMap();
      unmappedKey = getKeyNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    assertFalse(map.containsKey(unmappedKey));
    try {
      assertFalse(map.containsKey(new IncompatibleKeyType()));
    } catch (ClassCastException tolerated) {
    }
    assertTrue(map.containsKey(map.keySet().iterator().next()));

    }

    public void test_multipleCatches() {
        // Test with multiple catch blocks
        boolean caughtSpecific = false;
        boolean caughtRuntime = false;

        try {
            throw new DictionaryExpiredException();
        } catch (DictionaryExpiredException e) {
            caughtSpecific = true;
        } catch (RuntimeException e) {
            caughtRuntime = true;
        }

        try {
            return prompter.prompt(null);
        } catch (org.apache.maven.api.services.PrompterException e) {
            throw new IOException("Unable to prompt", e);
        }
    }

    @Override
    public String readPassword() throws IOException {
        try {
            return prompter.promptForPassword(null);
        } catch (org.apache.maven.api.services.PrompterException e) {

        SmbException ex = assertThrows(SmbException.class, sut::watch, "Expected SmbException when handle invalid");
        assertTrue(ex.getMessage().contains("Watch was broken by tree disconnect"));
    }

    // Happy path for SMB2: a response is received and the list is returned; tree is closed
    @Test
    @DisplayName("watch() SMB2 happy path returns notifications and closes tree")

          "match": "*_bn",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

            } catch (NumberFormatException e) {
                // Invalid value ignored
            }
        }

        value = props.getProperty("jcifs.smb.client.soTimeout");
        if (value != null) {
            try {
                this.smbSocketTimeout = Integer.parseInt(value);
            } catch (NumberFormatException e) {
                // Invalid value ignored

    boolean hasNextAddress() {
        return addressIndex < addresses.length;
    }

    void connect0() throws SmbException {
        try {
            connect();
        } catch (final SmbException se) {
            throw se;
        } catch (final IOException ioe) {
            throw new SmbException("Failed to connect to server", ioe);
        }
    }

    void doConnect() throws IOException {

    /**
     * Creates a directory watch
     *
     * The server will notify the client when there are changes to the directories contents
     *
     * @param filter
     *            see constants in {@link FileNotifyInformation}
     * @param recursive
     *            whether to also watch subdirectories
     * @return watch context, needs to be closed when finished

            try {
                serverSideCopy(src, dest, sh, dh, false);
                return;
            } catch (final SmbUnsupportedOperationException e) {
                log.debug("Server side copy not supported, falling back to normal copying", e);
            } catch (final CIFSException e) {
                log.warn("Server side copy failed", e);
                throw SmbException.wrap(e);
            }