{
            "detail": [
                {
                    "type": "string_pattern_mismatch",
                    "loc": ["query", "item-query"],
                    "msg": "String should match pattern '^fixedquery$'",
                    "input": "nonregexquery",
                    "ctx": {"pattern": "^fixedquery$"},
                }
            ]
        }
    ) | IsDict(

Krishnan Parthasarathi <******@****.***> 1701514293 -0800

				t.Fatalf("Expected %v but got %v", test.want, got)
			}
		})
	}
}

func TestBatchJobSizeValidate(t *testing.T) {
	errInvalidBatchJobSizeFilter := BatchJobYamlErr{
		msg: "invalid batch-job size filter",
	}

	tests := []struct {
		sizeFilter BatchJobSizeFilter
		err        error
	}{
		{
			// Unspecified size filter is a valid filter
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 0,

      "virtual_hosts": [
       {
        "name": "backend",
        "domains": [
         "*"
        ],
        "routes": [
         {
          "match": {
           "prefix": "/healthz/ready"
          },
          "route": {
           "cluster": "agent"
          }
         }
        ]
       }
      ]
     },

      "CallEnd",
    )
  }

  private fun assertBytesReadWritten(
    listener: RecordingEventListener,
    requestHeaderLength: Matcher<Long?>?,
    requestBodyBytes: Matcher<Long?>?,
    responseHeaderLength: Matcher<Long?>?,
    responseBodyBytes: Matcher<Long?>?,
  ) {
    if (requestHeaderLength != null) {
      val responseHeadersEnd = listener.removeUpToEvent<RequestHeadersEnd>()

					return
				}
			}
		case "Batch":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Batch")
					return
				}
				z.Batch = nil
			} else {
				if z.Batch == nil {
					z.Batch = new(int)
				}
				*z.Batch, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, "Batch")
					return
				}
			}

    Object[] actual = getList().toArray();
    assertArrayEquals("toArray() order should match list", createOrderedArray(), actual);
  }

  @CollectionSize.Require(absent = ZERO)
  public void testToArray_tooSmall() {
    Object[] actual = getList().toArray(new Object[0]);
    assertArrayEquals("toArray(tooSmall) order should match list", createOrderedArray(), actual);
  }

  public void testToArray_largeEnough() {

      "virtual_hosts": [
       {
        "name": "backend",
        "domains": [
         "*"
        ],
        "routes": [
         {
          "match": {
           "prefix": "/stats/prometheus"
          },
          "route": {
           "cluster": "prometheus_stats"
          }
         }
        ]
       }
      ]
     },

func (rulesMap RulesMap) MatchSimple(eventName Name, objectName string) bool {
	return rulesMap[eventName].MatchSimple(objectName)
}

// Match - returns TargetIDSet matching object name and event name in rules map.
func (rulesMap RulesMap) Match(eventName Name, objectName string) TargetIDSet {
	return rulesMap[eventName].Match(objectName)
}

// NewRulesMap - creates new rules map with given values.

            propMap.put(CRAWLER_METADATA_CONTENT_EXCLUDES, patterns);
        }
        return !stream(patterns).get(stream -> stream.anyMatch(p -> p.matcher(name).matches()));
    }

    String getCrawlerMetadataNameMapping();

    default Tuple3<String, String, String> getCrawlerMetadataNameMapping(final String name) {
        @SuppressWarnings("unchecked")