create().isEmpty();
    create().iterator();
    create().remove("foo");
    create().removeAll(ImmutableList.of("foo"));
    create().retainAll(ImmutableList.of("foo"));
    create().size();
    create().toArray();
    create().toArray(new String[] {"foo"});
    create().addFirst("e");
    create().addLast("e");
    create().offerFirst("e");
    create().offerLast("e");
    create().removeFirst();

      this.gen = gen;
    }

    @Override
    public SampleElements<E> samples() {
      return gen.samples();
    }

    @Override
    public Set<E> create(Object... elements) {
      return (Set<E>) SerializableTester.reserialize(gen.create(elements));
    }

    @Override
    public E[] createArray(int length) {
      return gen.createArray(length);
    }

    @Override

        MapTestSuiteBuilder.using(
                new TestStringMapGenerator() {
                  @Override
                  protected Map<String, String> create(Entry<String, String>[] entries) {
                    Map<String, String> map = CompactLinkedHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }

		// Failed to create NewMultipartUpload, abort.
		t.Fatalf("%s : %s", instanceType, err.Error())
	}

	err = obj.MakeBucket(context.Background(), "abc", MakeBucketOptions{})
	if err != nil {
		// Failed to create newbucket, abort.
		t.Fatalf("%s : %s", instanceType, err.Error())
	}

	resN, err := obj.NewMultipartUpload(context.Background(), "abc", "def", opts)
	if err != nil {

        // Since we can't directly verify the internal state, we create a new request to test
        Smb2CloseRequest newRequest = new Smb2CloseRequest(mockConfig, testFileId);
        assertNotNull(newRequest, "Should create request with new file ID");
    }

    @Test
    @DisplayName("Should handle null file ID")
    void testSetNullFileId() {

        // Configure OEM encoding to avoid NullPointerException
        when(mockConfig.getOemEncoding()).thenReturn("UTF-8");
    }

    @Test
    @DisplayName("Constructor with Configuration only should create empty Name instances")
    void testConstructorWithConfigOnly() {
        SessionRequestPacket packet = new SessionRequestPacket(mockConfig);

        assertNotNull(packet);

        v.add(new DERTaggedObject(true, 2, new DERBitString(new byte[] { 0x01 })));

        // Create a custom APPLICATION tagged object that throws IOException when encoding
        // We need to create a proper ASN1TaggedObject with APPLICATION tag class
        // Create a custom base object that throws IOException
        ASN1Encodable badBase = new ASN1Encodable() {
            @Override

        // Create mock HTTP handler
        URLStreamHandler httpHandler = new URLStreamHandler() {
            @Override
            protected URLConnection openConnection(URL u) throws IOException {
                return mock(HttpURLConnection.class);
            }
        };

        // Create mock HTTPS handler
        URLStreamHandler httpsHandler = new URLStreamHandler() {

@DisplayName("SpnegoException Tests")
class SpnegoExceptionTest extends BaseTest {

    @Test
    @DisplayName("Should create SpnegoException with default constructor")
    void testDefaultConstructor() {
        // When
        SpnegoException ex = new SpnegoException();

        // Then
        assertNotNull(ex, "Exception should be created");
        assertNull(ex.getMessage(), "Default message should be null");

    return new TestStringMultisetGenerator() {
      @Override
      protected Multiset<String> create(String[] elements) {
        return HashMultiset.create(asList(elements));
      }
    };
  }

  public void testCreate() {
    Multiset<String> multiset = HashMultiset.create();
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());