try {
                decoded.decode(buffer, 200, encoded);
                assertArrayEquals(ciphers, decoded.getCiphers());
            } catch (SMBProtocolDecodingException e) {
                fail("Should not throw exception: " + e.getMessage());
            }
        }

        @Test
        @DisplayName("Should verify cipher constants")

    public boolean contains(@Nullable Object o) {
      if (o == null) {
        return false;
      }
      try {
        @SuppressWarnings("unchecked") // we catch CCE's
        C c = (C) o;
        return ImmutableRangeSet.this.contains(c);
      } catch (ClassCastException e) {
        return false;
      }
    }

    @Override
    int indexOf(@Nullable Object target) {
      if (contains(target)) {

                generator.saveImage(input, outputFile);
            }
            assertImageSize(outputFile, 100, 100);
        } catch (IllegalStateException e) {
            // Expected when container is not initialized
            if (e.getMessage().contains("Not initialized")) {
                // Skip test when container is not available

          collection.removeIf(
              x -> {
                throw new AssertionError("predicate should never be called");
              }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)

    // URL escapers should throw null pointer exceptions for null input
    try {
      e.escape((String) null);
      fail("Escaping null string should throw exception");
    } catch (NullPointerException x) {
      // pass
    }

    // All URL escapers should leave 0-9, A-Z, a-z unescaped
    assertUnescaped(e, 'a');
    assertUnescaped(e, 'z');
    assertUnescaped(e, 'A');

            if (object instanceof Entry<?, ?> && ((Entry<?, ?>) object).getKey() == null) {
              return false;
            }
            try {
              return super.contains(object);
            } catch (ClassCastException e) {
              return false;
            }
          }

          @Override
          @SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations

            if (p == -1) {
                p = 21;
            }
            if (port > 0 && port != p) {
                return false;
            }
            return true;
        } catch (final Exception e) {
            // Log the exception at debug level because an invalid URI is not critical and can be ignored.
            logger.debug("Invalid URI: {}", path, e);
        }
        return false;
    }

        assertEquals("Shift_JIS", encoding);
    }

    public void test_getHtml_null() {
        try {
            htmlXpathExtractor.getText(null, null);
            fail();
        } catch (final CrawlerSystemException e) {
            // NOP
        }
    }

import static com.google.common.collect.testing.features.MapFeature.ALLOWS_NULL_KEY_QUERIES;
import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_REMOVE;
import static java.lang.Math.max;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multisets;

                        // The actual server name might be different from TEST_HOSTNAME based on how getHostName() works
                    }
                }

            } catch (Exception e) {
                fail("Failed to invoke makeTargetInfo via reflection: " + e.getMessage());
            }
        }

        @Test
        @DisplayName("makeTargetInfo should handle missing domain")