jsonWriter.beginArray();
        contents.write();
        endArray();
    }

    protected void beginArray(String name) throws IOException {
        jsonWriter.name(name);
        jsonWriter.beginArray();
    }

    protected void endArray() throws IOException {
        jsonWriter.endArray();
    }

    protected void writeObject(String name, Contents contents) throws IOException {

                .startArray("result");

            for(String word: response.getWords()) {
                builder.value(word);
            }

            String json = builder.endArray()
                .endObject()
                .endArray()
                .endObject()
                .endObject().string();
            if(callback != null && callback.length > 0) {
                json = callback[0] + '(' + json + ')';

        var first = true
        list.forEach {
            if (first) first = false else comma()
            body(it)
        }
        endArray()
    }

    private
    fun beginArray() {
        write('[')
    }

    private
    fun endArray() {
        write(']')
    }

    private
    fun property(name: String, value: String) {
        property(name) { jsonString(value) }

        reader.beginArray();
        while (reader.peek() != JsonToken.END_ARRAY) {
            consumeVariant(reader, metadata);
        }
        reader.endArray();
    }

    private void consumeVariant(JsonReader reader, MutableModuleComponentResolveMetadata metadata) throws IOException {
        String variantName = null;

                    if (candidate != null) {
                        installs.add(candidate);
                    }
                }
                reader.endArray();
            } finally {
                reader.close();
            }
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }

            out.name("subcategories").beginArray();
            for (String sc : value.getSubcategories()) {
                out.value(sc);
            }
            out.endArray();
            out.endObject();
        }

        @Override
        public ProblemCategory read(JsonReader in) throws IOException {
            in.beginObject();
            String namespace = null;

    private List<Object> readArray(JsonReader reader) {
        List<Object> values = []
        reader.beginArray()
        while (reader.peek() != JsonToken.END_ARRAY) {
            Object value = readAny(reader)
            values.add(value)
        }
        reader.endArray()
        return values
    }

    static Map<String, String> normalizeForTests(Map<String, ?> attributes) {

from tensorflow.python.types import core
from tensorflow.python.util import tf_export

# A representative sample is a map of: input_key -> input_value.
# Ex.: {'dense_input': tf.constant([1, 2, 3])}
# Ex.: {'x1': np.ndarray([4, 5, 6]}
RepresentativeSample = Mapping[str, core.TensorLike]

# A representative dataset is an iterable of representative samples.
RepresentativeDataset = Iterable[RepresentativeSample]

                        break;
                    case "groups":
                        final List<String> list = new ArrayList<>();
                        while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
                            final String group = jsonParser.getText();
                            list.add(group);
                        }
                        if (logger.isDebugEnabled()) {

          sample, signature_def
      )
      input_tensor_data = input_tensor.eval()

    self.assertLen(feed_dict, 1)
    self.assertIn('input:0', feed_dict)
    self.assertIsInstance(feed_dict['input:0'], np.ndarray)
    self.assertAllEqual(feed_dict['input:0'], input_tensor_data)

  @test_util.deprecated_graph_mode_only
  def test_create_feed_dict_from_input_data_empty(self):
    signature_def = meta_graph_pb2.SignatureDef(