"testing"
)

func TestExitCodeFilter(t *testing.T) {
	// Write text to the filter one character at a time.
	var out strings.Builder
	f, exitStr := newExitCodeFilter(&out)
	// Embed a "fake" exit code in the middle to check that we don't get caught on it.
	pre := "abc" + exitStr + "123def"
	text := pre + exitStr + `1`
	for i := 0; i < len(text); i++ {
		_, err := f.Write([]byte{text[i]})
		if err != nil {
			t.Fatal(err)
		}

     * <p>
     * Gradle intentionally does not offer a global system/gradle property that allows a universal disable of this check.
     * <p>
     * <b>Allowing communication over insecure protocols allows for a man-in-the-middle to impersonate the intended server,
     * and gives an attacker the ability to

		{
			name: "ipv4 first is a one",
			ip:   netip.MustParseAddr("192.168.0.0"),
			pos:  1,
			want: 1,
		},
		{
			name: "ipv4 middle is a zero",
			ip:   netip.MustParseAddr("192.168.0.0"),
			pos:  16,
			want: 0,
		},
		{
			name: "ipv4 middle is a one",
			ip:   netip.MustParseAddr("192.168.0.0"),
			pos:  13,
			want: 1,
		},
		{
			name: "ipv4 last is a zero",

    for (V element : elements) {
      assertFalse("Should not contain value " + element, getMap().containsValue(element));
    }
  }

  /** @return an array of the proper size with {@code null} as the key of the middle element. */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];

  %a = tfrt_fallback_async.const_dense_tensor dense<[[4, 4], [4, 4]]> : tensor<2x2xi32>
  %b = tfrt_fallback_async.const_dense_tensor dense<[[1, 1], [1, 1]]> : tensor<2x2xi32>

  // One batch_size=2 batches get padded and processed after timeout.
  %result = tfrt_fallback_async.batch_function device("/device:CPU:0") @matmul_cpu (%a, %b) {
      num_batch_threads = 1,
      max_batch_size = 4,
      allowed_batch_sizes = [4],

}

const (
	wstateBegin     = iota // initial state; must be zero
	wstateBeginLine        // beginning of line
	wstateCR               // wrote \r (possibly at end of line)
	wstateData             // writing data in middle of line
)

func (d *dotWriter) Write(b []byte) (n int, err error) {
	bw := d.w.W
	for n < len(b) {
		c := b[n]
		switch d.state {
		case wstateBegin, wstateBeginLine:
			d.state = wstateData

#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_attributes.h"

namespace mlir {
namespace TFL {

// Abstracts the conversion of the padded NMS composite function.
class ConvertNMSPaddedFunc {
 public:
  explicit ConvertNMSPaddedFunc(func::FuncOp func) : func_(func) {}

  void RewriteFunc();

  LogicalResult VerifySignature();

 private:

	_ = a[1.0]
	_ = a[- /* ERROR "negative" */ 1]
	_ = a[- /* ERROR "negative" */ 1 :]
	_ = a[: - /* ERROR "negative" */ 1]
	_ = a[: /* ERROR "middle index required" */ : /* ERROR "final index required" */ ]
	_ = a[0: /* ERROR "middle index required" */ : /* ERROR "final index required" */ ]
	_ = a[0: /* ERROR "middle index required" */ :10]
	_ = a[:10:10]

	var a0 int
	a0 = a[0]
	_ = a0
	var a1 int32

<img src="/img/tutorial/extending-openapi/image03.png">

## Change the Theme

The same way you could set the syntax highlighting theme with the key `"syntaxHighlight.theme"` (notice that it has a dot in the middle):

```Python hl_lines="3"
{!../../../docs_src/configure_swagger_ui/tutorial002.py!}
```

That configuration would change the syntax highlighting color theme:

transform: rotate(135deg);
L144:  -webkit-transform: rotate(135deg);
L145:}
L146:
L147:.daterangepicker .calendar-table th, .daterangepicker .calendar-table td {
L148:  white-space: nowrap;
L149:  text-align: center;
L150:  vertical-align: middle;
L151:  min-width: 32px;
L152:  width: 32px;
L153:  height: 24px;
L154:  line-height: 24px;
L155:  font-size: 12px;
L156:  border-radius: 4px;
L157:  border: 1px solid transparent;
L158:  white-space: nowrap;
L159:  cursor: pointer;
L160:}
...