SmbEndOfFileException ex = new SmbEndOfFileException();

        // Act
        String text = ex.toString();

        // Assert
        assertNotNull(text);
        assertTrue(text.contains(expectedSubstring), "toString should contain: " + expectedSubstring);
    }

        roleSet = buildByParameter(roleQueryHelperImpl, getMockRequest());
        assertEquals(3, roleSet.size());
        assertTrue(roleSet.contains("role1"));
        assertTrue(roleSet.contains("role2"));
        assertTrue(roleSet.contains("role3"));

        roleQueryHelperImpl.parameterKey = "fess2";

        roleQueryHelperImpl.cipher = cipher;

  @Override
  public boolean containsKey(@Nullable Object key) {
    return findEntryByKey(key) != ABSENT;
  }

  /**
   * Returns {@code true} if this BiMap contains an entry whose value is equal to {@code value} (or,
   * equivalently, if this inverse view contains a key that is equal to {@code value}).
   *
   * <p>Due to the property that values in a BiMap are unique, this will tend to execute in
   * faster-than-linear time.
   *

    }

    @Test
    void testToString() {
        String result = setupAndX.toString();
        assertNotNull(result);
        assertTrue(result.contains("SmbComSessionSetupAndX"), "toString should contain class name");
    }

    int initialSize = getList().size();
    assertTrue("remove(present) should return true", getList().remove(duplicate));
    assertTrue(
        "After remove(duplicate), a list should still contain the duplicate element",
        getList().contains(duplicate));
    assertFalse(
        "remove(duplicate) should remove the first instance of the "
            + "duplicate element in the list",
        firstIndex == getList().indexOf(duplicate));

          fail(
              rootLocaleFormat(
                  "Feature enum %s contains a class named "
                      + "'Require' but it is not an annotation.",
                  featureEnumClass));
        }
        return;
      }
    }
    fail(
        rootLocaleFormat(
            "Feature enum %s should contain an annotation named 'Require'.", featureEnumClass));
  }

  @SuppressWarnings("unchecked")

    while (removeFrom.hasNext()) {
      if (!elementsToRetain.contains(removeFrom.next())) {
        removeFrom.remove();
        result = true;
      }
    }
    return result;
  }

  /**
   * Determines whether two iterators contain equal elements in the same order. More specifically,
   * this method returns {@code true} if {@code iterator1} and {@code iterator2} contain the same

    }

    @Override
    public boolean contains(@Nullable Object rowKey, @Nullable Object columnKey) {
      return fromTable.contains(rowKey, columnKey);
    }

    @Override
    public @Nullable V2 get(@Nullable Object rowKey, @Nullable Object columnKey) {
      // The function is passed a null input only when the table contains a null
      // value.

    int indexOf(@Nullable Object target) {
      if (contains(target)) {
        @SuppressWarnings("unchecked") // if it's contained, it's definitely a C
        C c = (C) requireNonNull(target);
        long total = 0;
        for (Range<C> range : ranges) {
          if (range.contains(c)) {
            return Ints.saturatedCast(total + ContiguousSet.create(range, domain).indexOf(c));
          } else {

  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    getSet().remove(e0());
    assertFalse(
        "After remove(present) a set should not contain the removed element.",
        getSet().contains(e0()));
  }