}
        for (T t : scenario.strictlyOrderedList) {
          composites.add(new Composite<T>(t, 2));
        }
        Ordering<Composite<T>> ordering =
            Ordering.<Composite<T>>natural()
                .compound(scenario.ordering.onResultOf(Composite.<T>getValueFunction()));
        return new Scenario<Composite<T>>(

        }
        for (T t : scenario.strictlyOrderedList) {
          composites.add(new Composite<T>(t, 2));
        }
        Ordering<Composite<T>> ordering =
            Ordering.<Composite<T>>natural()
                .compound(scenario.ordering.onResultOf(Composite.<T>getValueFunction()));
        return new Scenario<Composite<T>>(

	if err != nil {
		t.Fatalf("failed to parse productNonAutoIncrement struct with composite primary key, got error %v", err)
	}

	if productNonAutoIncrement.PrioritizedPrimaryField != nil {
		t.Fatalf("PrioritizedPrimaryField of non autoincrement composite key should be nil")
	}

        // Return just the base; caller is responsible for placing ctx at the correct absolute offset.
        // We will return a composite buffer from the test when building the full packet.
        // To keep this helper simple, return base and let the caller append/pad and inject ctx.
        return base;
    }

    /**

    val dateFormat =
      SimpleDateFormat("yyyyMMddHHmmss'Z'").apply {
        timeZone = utc
      }

    return dateFormat.format(date)
  }

  /**
   * Returns a composite adapter for a struct or data class. This may be used for both SEQUENCE and
   * SET types.
   *
   * The fields are specified as a list of member adapters. When decoding, a value for each

  override fun timeout(): Timeout = timeout

  override fun addEventListener(eventListener: EventListener) {
    // Atomically replace the current eventListener with a composite one.
    do {
      val previous = this.eventListener
    } while (!eventListenerUpdater.compareAndSet(this, previous, previous + eventListener))
  }

   * than one</i> that cannot be factored into a product of <i>smaller</i> positive integers.
   * Returns {@code false} if {@code n} is zero, one, or a composite number (one which <i>can</i> be
   * factored into smaller positive integers).
   *
   * <p>To test larger numbers, use {@link BigInteger#isProbablePrime}.
   *