token: "Bearer xxxxx" # optional authentication token for the notification endpoint

	retry:
	  attempts: 10 # number of retries for the job before giving up
	  delay: "500ms" # least amount of delay between each retry
```

You can create and run multiple 'replication' jobs at a time there are no predefined limits set.

## Batch Jobs Terminology

### Job

        Element tr = getChild(thead, "tr");
        List<Element> header = children(tr, "td");
        if (header.size() < 1) {
            throw new RuntimeException(String.format("Expected at least 1 <td> in <thead>/<tr>, found: %s", header));
        }
        Map<String, Element> inheritedValueTitleMapping = new HashMap<String, Element>();
        List<Element> valueTitles = new ArrayList<Element>();

    // one. (StringCoding$StringDecoder vs. StreamDecoder).  StringCoding has a ton of special cases
    // theoretically we could duplicate all that logic here to try to beat 'new String' or at least
    // come close.
    USING_DECODER_WITH_SIZE_HINT {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        Optional<Long> size = byteSource.sizeIfKnown();

        .isEqualTo("At least one TLS version is required")
    }
  }

  @Test
  fun noCipherSuites() {
    assertFailsWith<IllegalArgumentException> {
      ConnectionSpec
        .Builder(ConnectionSpec.MODERN_TLS)
        .cipherSuites(*arrayOf<CipherSuite>())
        .build()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("At least one cipher suite is required")
    }
  }

import java.io.IOException;
import java.nio.file.Files;
import java.util.*;

/**
 * Checks adoc files for reversed multi-language snippet order.
 * Only rule enforced:
 *   In a ==== ... ==== block, if there are at least two [.multi-language-sample] snippets,
 *   flag when the first is GROOVY and the second is KOTLIN.
 */
@CacheableTask
public abstract class FindBadMultiLangSnippets extends DefaultTask {

    @InputDirectory

    assert response.json() == {
        "detail": [
            {
                "type": "string_too_short",
                "loc": ["path", "item_id"],
                "msg": "String should have at least 3 characters",
                "input": "fo",
                "ctx": {"min_length": 3},
            }
        ]
    }


def test_path_param_maxlength_foo():

 */
@GwtIncompatible
abstract class ToDoubleRounder<X extends Number & Comparable<X>> {
  /**
   * Returns x rounded to either the greatest double less than or equal to the precise value of x,
   * or the least double greater than or equal to the precise value of x.
   */
  abstract double roundToDoubleArbitrarily(X x);

  /** Returns the sign of x: either -1, 0, or 1. */
  abstract int sign(X x);

				writeLastByte = true
				nf--
			}
			_, err = ws.Seek(nf, io.SeekCurrent)
		}
		sr.pos += nf
		if sr.pos >= holeEnd && len(sr.sp) > 1 {
			sr.sp = sr.sp[1:] // Ensure last fragment always remains
		}
	}

	// If the last fragment is a hole, then seek to 1-byte before EOF, and
	// write a single byte to ensure the file is the right size.
	if writeLastByte && err == nil {
		_, err = ws.Write([]byte{0})

        .signedBy(intermediate)
        .build()
    val handshakeCertificates =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(root.certificate) // BouncyCastle requires at least one
        .heldCertificate(certificate, intermediate.certificate)
        .build()
    assertPrivateKeysEquals(
      certificate.keyPair.private,
      handshakeCertificates.keyManager.getPrivateKey("private"),

     * The type for all paths that could not be placed in any of the types requested by a caller.
     * This type can appear in the return value of a call to
     * {@link Session#resolveDependencies resolveDependencies(...)} when at least one dependency
     * cannot be associated to any type specified in the {@code desiredTypes} argument.
     * Plugins can choose to report a warning to users when unresolved paths exist.
     */