// the actual benchmark for PutObject starts here. Reset the benchmark timer.
	b.ResetTimer()

	if err := req.ParseForm(); err != nil {
		b.Fatal(err)
	}

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			req.Form.Get("uploadId")
		}
	})

	// Benchmark ends here. Stop timer.
	b.StopTimer()
}

// BenchmarkURLQuery - benchmark URL memory allocations
func BenchmarkURLQuery(b *testing.B) {

        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("Test decode with non-aligned next entry offset throws exception")
    void testDecodeNonAlignedNextOffset() {
        byte[] buffer = new byte[100];
        // Write non-aligned next entry offset (not divisible by 4)
        SMBUtil.writeInt4(7, buffer, 0); // 7 is not aligned to 4 bytes

        Entry<TypeVariable<?>, Type> entry = it.next();
        assertThat(entry.getKey().getName(), is("T1"));
        assertThat(entry.getValue(), is(sameClass(Integer.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T2"));
        assertThat(entry.getValue(), is(sameClass(Long.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T1"));

    }

    /**
     * Checks if there is a next page available.
     *
     * @return true if there is a next page, false otherwise
     */
    public boolean isExistNextPage() {
        return existNextPage;
    }

    /**
     * Sets whether there is a next page available.
     *
     * @param existNextPage true if there is a next page, false otherwise
     */

      String nextSeparator = "";
      StringBuilder builder = new StringBuilder(32).append(className).append('{');
      for (ValueHolder valueHolder = holderHead.next;
          valueHolder != null;
          valueHolder = valueHolder.next) {
        Object value = valueHolder.value;
        if (valueHolder instanceof UnconditionalValueHolder
            || (value == null
                ? !omitNullValuesSnapshot

    private final ReferenceEntry<K, V> next;

    public DummyEntry(K key, int hash, ReferenceEntry<K, V> next) {
      this.key = key;
      this.hash = hash;
      this.next = next;
    }

    public static <K, V> DummyEntry<K, V> create(
        K key, int hash, @Nullable ReferenceEntry<K, V> next) {
      return new DummyEntry<>(key, hash, next);
    }

    public void clearKey() {

     */
    @Override
    public boolean hasNext() {
        return false;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public SmbResource next() {
        return null;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CloseableIterator#close()
     */
    @Override

    }.test();
  }

  public void testIteratorNoSuchElementException() {
    Iterator<E> iterator = collection.iterator();
    while (iterator.hasNext()) {
      iterator.next();
    }

    assertThrows(NoSuchElementException.class, iterator::next);
  }

      protected @Nullable C computeNext() {
        while (merged.hasNext()) {
          C next = merged.next();
          boolean duplicate = lastValue != null && comparator.compare(next, lastValue) == 0;

          // Keep looping till we find a non-duplicate value.
          if (!duplicate) {
            lastValue = next;
            return lastValue;
          }
        }

		switch simd_type {
		case loong64.LSX:
			arng_type, ok = loong64LsxArngExtMap[ext]
			if !ok {
				return errors.New("Loong64 extension: invalid LSX arrangement type: " + ext)
			}

		case loong64.LASX:
			arng_type, ok = loong64LasxArngExtMap[ext]
			if !ok {
				return errors.New("Loong64 extension: invalid LASX arrangement type: " + ext)
			}
		}

		a.Reg = loong64.REG_ARNG