}

  override fun getSupportedCipherSuites(): Array<String> {
    return delegate!!.supportedCipherSuites
  }

  override fun getEnabledCipherSuites(): Array<String> {
    return delegate!!.enabledCipherSuites
  }

  override fun setEnabledCipherSuites(suites: Array<String>) {
    delegate!!.enabledCipherSuites = suites
  }

  override fun getSupportedProtocols(): Array<String> {
    return delegate!!.supportedProtocols

                        {
                            "required": False,
                            "schema": {
                                "title": "Q",
                                "type": "array",
                                "items": {"type": "string"},
                                "default": ["foo", "bar"],
                            },
                            "name": "q",

   */
  @CanIgnoreReturnValue
  PrimitiveSink putByte(byte b);

  /**
   * Puts an array of bytes into this sink.
   *
   * @param bytes a byte array
   * @return this instance
   */
  @CanIgnoreReturnValue
  PrimitiveSink putBytes(byte[] bytes);

  /**
   * Puts a chunk of an array of bytes into this sink. {@code bytes[off]} is the first byte written,
   * {@code bytes[off + len - 1]} is the last.
   *

      char[] chars = Chars.toArray(asList(elements));
      return charactersOf(String.copyValueOf(chars));
    }
  }

  public static class CharactersOfCharSequenceGenerator extends TestCharacterListGenerator {
    @Override
    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));
      StringBuilder str = new StringBuilder();

                    "type": "object",
                    "properties": {
                        "files": {
                            "title": "Files",
                            "type": "array",
                            "items": {"type": "string", "format": "binary"},
                            "description": "Multiple files as bytes",
                        }
                    },
                },

                                "in": "header",
                                "required": False,
                                "schema": {
                                    "type": "array",
                                    "items": {"type": "string"},
                                    "default": [],
                                    "title": "X Tag",
                                },

public abstract class DoublesMethodsForWeb {

  @JsMethod(name = "Math.min", namespace = JsPackage.GLOBAL)
  public static native double min(double... array);

  @JsMethod(name = "Math.max", namespace = JsPackage.GLOBAL)
  public static native double max(double... array);

                    "type": "object",
                    "properties": {
                        "files": {
                            "title": "Files",
                            "type": "array",
                            "items": {"type": "string", "format": "binary"},
                            "description": "Multiple files as bytes",
                        }
                    },
                },

  @CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testLastIndexOf_duplicate() {
    E[] array = createSamplesArray();
    array[getNumElements() / 2] = e0();
    collection = getSubjectGenerator().create(array);
    assertEquals(
        "lastIndexOf(duplicate) should return index of last occurrence",
        getNumElements() / 2,
        getList().lastIndexOf(e0()));
  }

                                    "schema": {
                                        "items": {"$ref": "#/components/schemas/Item"},
                                        "type": "array",
                                        "title": "Response Read Items Items  Get",
                                    }
                                }
                            },
                        }