isActive,
                                            isPermanent,
                                            macAddress );
                }
            }
        } catch( UnsupportedEncodingException uee ) {
        }
        return srcIndex - start;
    }
    public String toString() {
        return new String( "NodeStatusResponse[" +
            super.toString() + "]" );

                                writer.write(hit.getSourceAsString());
                                writer.write("\n");
                            } catch (final IOException e) {
                                throw new IORuntimeException(e);
                            }
                            return true;
                        });

    try {
      getMap()
          .computeIfPresent(
              k3(),
              (k, v) -> {
                throw new AssertionFailedError();
              });
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

        continue;
      }
      Class<?> clazz = info.load();
      try {
        Method unused = clazz.getDeclaredMethod("writeReplace");
        continue; // It overrides writeReplace, so it's safe.
      } catch (NoSuchMethodException e) {
        // This is a class whose supertypes we want to examine. We'll do that below.
      }
      Optional<Class<?>> supersWithPackagePrivateWriteReplace =

    }

    protected FilterChain createDefaultFilterChain() {
        return query -> {
            try {
                return createQueryParser().parse(query);
            } catch (final ParseException e) {
                throw new QueryParseException(e);
            }
        };
    }

    public interface Filter {
        Query parse(final String query, final FilterChain chain);

  @GwtIncompatible // reflection
  public static Field getField(Enum<?> enumValue) {
    Class<?>
        clazz = enumValue.getDeclaringClass();
    try {
      return clazz.getDeclaredField(enumValue.name());
    } catch (NoSuchFieldException impossible) {
      throw new AssertionError(impossible);
    }
  }

  /**
   * Returns an optional enum constant for the given type, using {@link Enum#valueOf}. If the

            return new ByteArrayInputStream(responseBodyBytes);
        }
        if (responseBodyFile != null) {
            try {
                return new FileInputStream(responseBodyFile);
            } catch (final FileNotFoundException e) {
                throw new IORuntimeException(e);
            }
        }
        return null;
    }

    public void setResponseBody(final byte[] responseBody) {

        try {
            return versionScheme.parseVersion(spec);
        } catch (InvalidVersionSpecificationException e) {
            throw new RuntimeException(e);
        }
    }

    private VersionRange parseVersionRange(String spec) {
        try {
            return versionScheme.parseVersionRange(spec);
        } catch (InvalidVersionSpecificationException e) {
            throw new RuntimeException(e);

        }

        if (pluginFile.isFile()) {
            try {
                return new URL("jar:" + pluginFile.toURI() + "!/" + descriptor).openStream();
            } catch (MalformedURLException e) {
                throw new IllegalStateException(e);
            }
        } else {
            return Files.newInputStream(new File(pluginFile, descriptor).toPath());
        }
    }

```Python hl_lines="6  11"
{!../../docs_src/path_params/tutorial003.py!}
```

Otherwise, the path for `/users/{user_id}` would match also for `/users/me`, "thinking" that it's receiving a parameter `user_id` with a value of `"me"`.

Similarly, you cannot redefine a path operation:

```Python hl_lines="6  11"