ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(),
            a,
            b1,
            c,
            b2);
    collector = toImmutableMultiset(e -> e, e -> 1);
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(),
            a,
            b1,

                for (final String result : results) {
                    // Add to result set (automatically handles duplicates)
                    if (resultSet.add(result) && resultSet.size() <= getMaxReadingNum()) {
                        nextInputs.add(result);
                    }
                }
            }

        projectBuilds.add(createProjectBuild(A, session, segment));
        projectBuilds.add(createProjectBuild(B, session, segment));
        projectBuilds.add(createProjectBuild(C, session, segment));
        projectBuilds.add(createProjectBuild(X, session, segment));
        projectBuilds.add(createProjectBuild(Y, session, segment));
        projectBuilds.add(createProjectBuild(Z, session, segment));

```

#### 2.2 Implementation Tasks
- [ ] Implement persistent/durable handle contexts
- [ ] Add handle GUID generation and tracking
- [ ] Implement handle state serialization
- [ ] Create reconnection logic with handle replay
- [ ] Add timeout management for durable handles
- [ ] Implement handle lease association
- [ ] Add persistent handle capability negotiation
- [ ] Create handle cache for reconnection

                                if (!Modifier.isFinal(currentField.getModifiers())) {
                                    fields.add(new StringField(currentField));
                                }
                            } else if (List.class.isAssignableFrom(type)) {
                                fields.add(new ListField(currentField));
                            } else if (Collection.class.isAssignableFrom(type)) {

	maps.Copy(setCopy, set)
	return setCopy
}

// add - adds TargetID to the set.
func (set TargetIDSet) add(targetID TargetID) {
	set[targetID] = struct{}{}
}

// Union - returns union with given set as new set.
func (set TargetIDSet) Union(sset TargetIDSet) TargetIDSet {
	nset := set.Clone()

	for k := range sset {
		nset.add(k)
	}

	return nset
}

RUN C:\TEMP\vs_community.exe \
        --quiet --wait --norestart --nocache \
        --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 \
        --add Microsoft.VisualStudio.Workload.NativeDesktop \
        --add Microsoft.VisualStudio.Component.VC.14.39.17.9.x86.64 \
        --add Microsoft.VisualStudio.Component.Windows11SDK.22621 \
 || IF "%ERRORLEVEL%"=="3010" EXIT 0

        .add(new Striped.LargeLazyStriped<Lock>(50, LOCK_SUPPLER))
        .add(new Striped.LargeLazyStriped<Lock>(64, LOCK_SUPPLER))
        .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))
        .add(new Striped.SmallLazyStriped<Semaphore>(64, SEMAPHORE_SUPPLER))
        .add(new Striped.LargeLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))

        .add(new Striped.LargeLazyStriped<Lock>(50, LOCK_SUPPLER))
        .add(new Striped.LargeLazyStriped<Lock>(64, LOCK_SUPPLER))
        .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))
        .add(new Striped.SmallLazyStriped<Semaphore>(64, SEMAPHORE_SUPPLER))
        .add(new Striped.LargeLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))

  public void testAdd_supportedNotPresent() {
    assertTrue("add(notPresent) should return true", collection.add(e3()));
    expectAdded(e3());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  public void testAdd_unsupportedNotPresent() {
    assertThrows(UnsupportedOperationException.class, () -> collection.add(e3()));
    expectUnchanged();
    expectMissing(e3());
  }