}

// JSON is a wrapper around a T object that can be serialized.
// There is an internal value
type JSON[T any] struct {
	p   *JSONPool[T]
	val *T
}

// NewJSON returns a new JSONPool.
// No initial value is set.
func (p *JSONPool[T]) NewJSON() *JSON[T] {
	var j JSON[T]
	j.p = p
	return &j
}

// NewJSONWith returns a new JSON with the provided value.

        }

        @Test
        @DisplayName("Should handle multiple parameter updates")
        void testMultipleParameterUpdates() {
            // Initial setup
            request.setData(new byte[100], 0, 100);
            request.setOffset(1000L);
            request.setRemainingBytes(500);
            request.setWriteFlags(0x01);

            // Update parameters

        assertEquals(Long.MAX_VALUE, crawlerContext.getMaxAccessCount());
    }

    /**
     * Test sitemaps add and remove operations
     */
    public void test_sitemaps() {
        // Initial state
        assertNull(crawlerContext.removeSitemaps());

        // Add sitemaps
        String[] sitemaps = new String[] { "http://example.com/sitemap.xml", "http://test.com/sitemap.xml" };

            }
        } finally {
            legacySupport.setSession(null);
        }

        return result;
    }

    //
    // 1) Setup initial properties.
    //
    // 2) Validate local repository directory is accessible.
    //
    // 3) Create RepositorySystemSession.
    //
    // 4) Create MavenSession.
    //

    return new Builder(initialCapacity);
  }

  /**
   * Returns a new, empty builder for {@link ImmutableLongArray} instances, with a default initial
   * capacity. The returned builder is not thread-safe.
   *
   * <p><b>Performance note:</b> The {@link ImmutableLongArray} that is built will very likely

  /**
   * Returns the number of additional elements that this queue can ideally (in the absence of memory
   * or resource constraints) accept without blocking. This is always equal to the initial capacity
   * of this queue less the current {@code size} of this queue.
   *
   * <p>Note that you cannot always tell if an attempt to insert an element will succeed by

    return new Builder(initialCapacity);
  }

  /**
   * Returns a new, empty builder for {@link ImmutableIntArray} instances, with a default initial
   * capacity. The returned builder is not thread-safe.
   *
   * <p><b>Performance note:</b> The {@link ImmutableIntArray} that is built will very likely occupy

    @DisplayName("Path Consumed Tests")
    class PathConsumedTests {

        @Test
        @DisplayName("Should strip path consumed correctly")
        void testStripPathConsumed() {
            // Set initial pathConsumed using fromReferral
            setupReferralDataWithPathConsumed(10);

            referralData.stripPathConsumed(5);
            assertEquals(5, referralData.getPathConsumed());
        }

      connection.flush()
      cancelStreamIfNecessary()
    }
  }

  companion object {
    internal const val EMIT_BUFFER_SIZE = 16384L
  }

  /** [delta] will be negative if a settings frame initial window is smaller than the last. */
  fun addBytesToWriteWindow(delta: Long) {
    writeBytesMaximum += delta
    if (delta > 0L) {
      notifyAll()
    }
  }

  @Throws(IOException::class)

            assertEquals(24 + (24 * 4), bytesWritten);
        }

        @Test
        @DisplayName("Should handle file ID updates")
        void testFileIdUpdates() {
            // Initial file ID
            byte[] initialFileId = new byte[16];
            Arrays.fill(initialFileId, (byte) 0x11);
            request.setFileId(initialFileId);

            byte[] buffer1 = new byte[256];