{
	"id": "0001",
	"type": "donut",
	"name": "Cake",
	"ppu": 0.55,
	"batters":
		{
			"batter":
				[
					{ "id": "1001", "type": "Regular" },
					{ "id": "1002", "type": "Chocolate" },
					{ "id": "1003", "type": "Blueberry" },
					{ "id": "1004", "type": "Devil's Food" }
				]
		},
	"topping":
		[
			{ "id": "5001", "type": "None" },
			{ "id": "5002", "type": "Glazed" },
			{ "id": "5005", "type": "Sugar" },

  internal const val PAYLOAD_LONG = 127

  /** Used when an unchecked exception was thrown in a listener. */
  internal const val CLOSE_CLIENT_GOING_AWAY = 1001

  /** Used when an empty close frame was received (i.e., without a status code). */
  internal const val CLOSE_NO_STATUS_CODE = 1005

  fun toggleMask(
    cursor: Buffer.UnsafeCursor,
    key: ByteArray,
  ) {
    var keyIndex = 0
    val keyLength = key.size

    serverWriter.writeClose(0, null)
    assertData("8800")
  }

  @Test fun serverCloseWithCode() {
    serverWriter.writeClose(1001, null)
    assertData("880203e9")
  }

  @Test fun serverCloseWithCodeAndReason() {
    serverWriter.writeClose(1001, "Hello".encodeUtf8())
    assertData("880703e948656c6c6f")
  }

  @Test fun clientEmptyClose() {
    clientWriter.writeClose(0, null)

# ADR-0004 - Use a platform-oriented architecture for Gradle

## Status

- ACCEPTED on 2024-02-07

## Context

The Gradle code base is essentially a large monolith, without strong internal boundaries.
This has a number of negative effects on productivity, including:

- Unclear ownership of code.
- Difficult to focus on one particular area.
- Unintended coupling between areas of the code, including tests.

## Decision

    ticker.advance(1);
    assertThat(stopwatch.toString()).isEqualTo("1.000 ns");
    ticker.advance(998);
    assertThat(stopwatch.toString()).isEqualTo("999.0 ns");
    ticker.advance(1);
    assertThat(stopwatch.toString()).isEqualTo("1.000 \u03bcs");
    ticker.advance(1);
    assertThat(stopwatch.toString()).isEqualTo("1.001 \u03bcs");
    ticker.advance(8998);

    table1.put("foo", 1, 'a');
    assertEquals((Character) 'a', table1.get("foo", 1));

    Table<String, Integer, Character> table2 = HashBasedTable.create(100, 0);
    table2.put("foo", 1, 'a');
    assertEquals((Character) 'a', table2.get("foo", 1));

    Table<String, Integer, Character> table3 = HashBasedTable.create(0, 20);
    table3.put("foo", 1, 'a');

    this.isUserTypeFast = isUserTypeFast;
    this.random = checkNotNull(random);
    this.hitRate = hitRate;
    this.size = size;

    this.valuesInSet = createData();
    this.queries = createQueries(valuesInSet, 1024);
  }

  Set<Element> getValuesInSet() {
    return valuesInSet;
  }

  Element[] getQueries() {
    return queries;
  }

  private Element[] createQueries(Set<Element> elementsInSet, int numQueries) {

				if len(in.input) == 0 {
					in.dst <- nil
					continue
				}
				dst := r.kvDstPool.Get()
				if len(dst) < 1000 {
					dst = make([]jstream.KVS, 0, 1000)
				}

				d := jstream.NewDecoder(bytes.NewBuffer(in.input), 0).ObjectAsKVS().MaxDepth(100)
				stream := d.Stream()
				all := dst[:0]
				for mv := range stream {
					var kvs jstream.KVS
					if mv.ValueType == jstream.Object {

    return ImmutableList.of(
        Striped.readWriteLock(100),
        Striped.readWriteLock(256),
        Striped.lock(100),
        Striped.lock(256),
        Striped.custom(100, FAIR_LOCK_SUPPLER),
        Striped.custom(256, FAIR_LOCK_SUPPLER),
        Striped.semaphore(100, 1),
        Striped.semaphore(256, 1));
  }

    return ImmutableList.of(
        Striped.readWriteLock(100),
        Striped.readWriteLock(256),
        Striped.lock(100),
        Striped.lock(256),
        Striped.custom(100, FAIR_LOCK_SUPPLER),
        Striped.custom(256, FAIR_LOCK_SUPPLER),
        Striped.semaphore(100, 1),
        Striped.semaphore(256, 1));
  }