cipherSuitesAsString.intersect(socketEnabledCipherSuites, CipherSuite.ORDER_BY_NAME)
  } else {
    socketEnabledCipherSuites
  }
}

internal fun MediaType?.chooseCharset(): Pair<Charset, MediaType?> {
  var charset: Charset = Charsets.UTF_8
  var finalContentType: MediaType? = this
  if (this != null) {
    val resolvedCharset = this.charset()
    if (resolvedCharset == null) {

  @JvmOverloads
  constructor(
    val requiredPlatformName: String? = null,
    val platform: Platform? = null,
  ) : BeforeEachCallback, AfterEachCallback, InvocationInterceptor {
    private val versionChecks = mutableListOf<Pair<Matcher<out Any>, Matcher<out Any>>>()

    override fun beforeEach(context: ExtensionContext) {
      setupPlatform()
    }

    override fun afterEach(context: ExtensionContext) {
      resetPlatform()
    }

		nsecs = -(nsecs - 1e9) // Take that second away from nsecs
	}
	return strings.TrimRight(fmt.Sprintf("%s%d.%09d", sign, secs, nsecs), "0")
}

// parsePAXRecord parses the input PAX record string into a key-value pair.
// If parsing is successful, it will slice off the currently read record and
// return the remainder as r.
func parsePAXRecord(s string) (k, v, r string, err error) {
	// The size field ends at the first space.

 *   <li>comparing each object against null returns false
 *   <li>comparing each object against an instance of an incompatible class returns false
 *   <li>comparing each pair of objects within the same equality group returns true
 *   <li>comparing each pair of objects from different equality groups returns false
 *   <li>the hash codes of any two equal objects are equal
 * </ul>
 *

    // any values in that range. To see why, consider the case where:
    // safeMin <= {hi,lo} <= safeMax
    // where {hi,lo} are characters forming a surrogate pair such that:
    // codePointOf(hi, lo) > safeMax
    // which would result in the surrogate pair being (wrongly) considered safe.
    // If we clip the safe range used during the per-character tests so it is

   * column key {@code c}, the returned table contains a mapping with row key {@code r} and column
   * key {@code c}. If that row key / column key pair in not in {@code table}, the pair maps to
   * {@code null} in the generated table.
   *
   * <p>The returned table allows subsequent {@code put} calls with the row keys in {@code

   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  @SuppressWarnings({
    // We use this method only for cases in which we need to decompose to primitives.
    "GoodTime-ApiWithNumericTimeUnit",
    "GoodTime-DecomposeToPrimitive",

          <defaultValue></defaultValue>
          <identifier>true</identifier>
        </field>
        <field>
          <name>extension</name>
          <version>1.1.0+</version>
          <type>String</type>
          <description>The file extension of the sub-artifact. Each classifier and extension pair may only appear once.</description>

//      output tensor naming, but it the index is actually an input index)
struct EdgeSpec : public std::pair<string, string> {
  typedef std::pair<string, string> Base;

  // Inherit the set of constructors
  using Base::pair;

  string ToString() const { return strings::StrCat(first, "->", second); }
};

class CApiFunctionTest : public ::testing::Test {
 protected:

            throw new CIFSException("Missing AvEOL");
        }
        return pairs;
    }


    /**
     * 
     * @param pairs
     * @param type
     * @return whether the list contains a pair of that type
     */
    public static boolean contains ( List<AvPair> pairs, int type ) {
        if ( pairs == null ) {
            return false;
        }
        for ( AvPair p : pairs ) {