public void testRemove_occurrences_unsupported_absent() {
    // notice: we don't care whether it succeeds, or fails with UOE
    try {
      assertEquals(
          "multiset.remove(absent, 2) didn't return 0 or throw an exception",
          0,
          getMultiset().remove(e3(), 2));
    } catch (UnsupportedOperationException ok) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)

        case 2:
          k1 ^= (long) toUnsignedInt(bb.get(1)) << 8; // fall through
        case 1:
          k1 ^= (long) toUnsignedInt(bb.get(0));
          break;
        default:
          throw new AssertionError("Should never get here.");
      }
      h1 ^= mixK1(k1);
      h2 ^= mixK2(k2);
    }

    @Override
    protected HashCode makeHash() {
      h1 ^= length;
      h2 ^= length;

    List<Object> invalidated = new ArrayList<>();
    Cache<Integer, Integer> cache =
        new AbstractCache<Integer, Integer>() {
          @Override
          public Integer getIfPresent(Object key) {
            throw new UnsupportedOperationException();
          }

          @Override
          public void invalidate(Object key) {
            invalidated.add(key);
          }
        };

  public void testRemove_occurrences_unsupported_absent() {
    // notice: we don't care whether it succeeds, or fails with UOE
    try {
      assertEquals(
          "multiset.remove(absent, 2) didn't return 0 or throw an exception",
          0,
          getMultiset().remove(e3(), 2));
    } catch (UnsupportedOperationException ok) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)

        try {
            String xmlContent = build();
            Editor editor = new Editor(Document.of(xmlContent));
            return editor.document();
        } catch (Exception e) {
            throw new RuntimeException("Failed to build POM document", e);
        }
    }

    private record Parent(String groupId, String artifactId, String version) {}

                });
            }
            return result;
        } catch (final Exception e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

        val matches: List<ResolvedComponentResult> = resolutionResult.allComponents.filter { it != resolutionResult.root }
        if (matches.isEmpty()) {
            throw GradleException("Could not locate any matches for $notation")
        }
        matches.forEach { dep -> dest[name] = (dep.id as ModuleComponentIdentifier).version }
    }

        void testConstructorSucceeds(String systemName, int accessMask) {
            // Arrange
            SamrPolicyHandle ph = createMockPolicyHandle();

            // Act & Assert - constructor should not throw
            assertDoesNotThrow(() -> new MsrpcSamrConnect2(systemName, accessMask, ph));
        }

        @Test
        @DisplayName("should create instance with valid parameters")

import org.junit.jupiter.api.TestInfo;

public class DataStoreParamsTest extends UnitFessTestCase {

    private DataStoreParams dataStoreParams;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        dataStoreParams = new DataStoreParams();
    }

    // Test default constructor
    @Test
    public void test_defaultConstructor() {

   * @param expectedSize the number of elements you expect to add to the returned set
   * @return a new, empty {@code CompactLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> createWithExpectedSize(int expectedSize) {