// Verify the peer received what was expected.
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_PING)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_HEADERS)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_PING)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_DATA)
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_RST_STREAM)
  }

  @Test fun outgoingWritesAreBatched() {

                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},
                        },
                    },
                }
            },
        }
    )

        "datasource": {
          "type": "datasource",
          "uid": "grafana"
        },
        "enable": true,
        "hide": true,
        "iconColor": "rgba(0, 211, 255, 1)",
        "name": "Annotations & Alerts",
        "target": {
          "limit": 100,
          "matchAny": false,
          "tags": [],
          "type": "dashboard"
        },
        "type": "dashboard"
      }
    ]
  },

      },
      "stopword_en_filter": {
        "type": "stop",
        "stopwords": "_english_"
      },
      "content_length_filter": {
        "type": "length",
        "max": 30
      },
      "limit_token_count_filter": {
        "type": "limit",
        "max_token_count": 2147483647
      },
      "stemmer_en_filter": {
        "type": "stemmer",
        "name": "english"
      },

        "type" : "custom",
        "tokenizer" : "standard"
      },
      "reading_term_analyzer_sq" : {
        "type" : "custom",
        "tokenizer" : "standard"
      },
      "normalize_analyzer_sq" : {
        "type" : "custom",
        "tokenizer" : "keyword",
        "char_filter" : ["mapping_char"],
        "filter" : ["lowercase"]
      },
      "contents_analyzer_sq" : {
        "type" : "custom",

    }

    /**
     * Creates and returns a new instance of {@link EnumMap}.
     *
     * @param <K> the key type of {@link EnumMap}
     * @param <V> the value type of {@link EnumMap}
     * @param keyType the class object of the key type for this {@literal enum} map
     * @return a new instance of {@link EnumMap}
     * @see EnumMap#EnumMap(Class)
     */

                        "required": ["loc", "msg", "type"],
                        "type": "object",
                        "properties": {
                            "loc": {
                                "title": "Location",
                                "type": "array",
                                "items": {
                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },

						<!-- Add libs -->
						<data>
							<type>directory</type>
							<src>${project.build.directory}/tomcat-lib</src>
							<mapper>
								<type>perm</type>
								<prefix>${packaging.fess.lib.dir}/classes</prefix>
								<user>${packaging.fess.user}</user>
								<group>${packaging.fess.group}</group>
							</mapper>
						</data>
						<data>
							<type>files</type>
							<paths>

    assertNotPrimitive(type);
    assertEquals(TypeToken.of(Primitives.unwrap((Class<?>) type.getType())), type.unwrap());
  }

  private static void assertNotWrapper(TypeToken<?> type) {
    assertThat(type.unwrap()).isEqualTo(type);
  }

  private static void assertNotPrimitiveNorWrapper(TypeToken<?> type) {
    assertNotPrimitive(type);
    assertNotWrapper(type);
  }

		attempts := attempts
		// one of source/target is s3, skip delete marker and all versions under the same object name.
		s3Type := r.Target.Type == BatchJobReplicateResourceS3 || r.Source.Type == BatchJobReplicateResourceS3
		minioSrc := r.Source.Type == BatchJobReplicateResourceMinIO
		ctx, cancel := context.WithCancel(ctx)

		objInfoCh := make(chan minio.ObjectInfo, 1)
		go func() {