* URLs</a>. (<a href="https://url.spec.whatwg.org/#path-state">If the escaper were to leave these
   * characters unescaped, they would be escaped by the consumer at parse time, anyway.</a>)
   * Additionally, the escaper escapes the slash character ("/"). While slashes are acceptable in
   * URL paths, they are considered by the specification to be separators between "path segments."

	const table = "unique_struct"

	checkField := func(model interface{}, fieldName string, unique bool, uniqueIndex string) {
		stmt := &gorm.Statement{DB: DB}
		err := stmt.Parse(model)
		if err != nil {
			t.Fatalf("%v: failed to parse schema, got error: %v", utils.FileWithLineNum(), err)
		}
		_ = stmt.Schema.ParseIndexes()
		field := stmt.Schema.LookUpField(fieldName)
		if field == nil {

        final VaMessenger<FessMessages> complexMessageCode =
                messages -> messages.addErrorsInvalidQueryParseError(UserMessages.GLOBAL_PROPERTY_KEY);
        final String message = "Failed to parse query: " + queryString;

        // Execute
        final InvalidQueryException exception = new InvalidQueryException(complexMessageCode, message);

        // Verify
        assertNotNull(exception);

        final QueryContext queryContext = new QueryContext(text, false);
        final Query query = ComponentUtil.getQueryParser().parse(queryContext.getQueryString());
        QueryBuilder builder = queryCommand.convertTermQuery(queryContext, (TermQuery) query, 1.0f);
        if (text.startsWith("sort:")) {
            assertNull(builder);
        } else {

			t.Errorf("(%d) failed to create http.Request, got %v", i, e)
		}

		// Do the same for the headers.
		for key, value := range testCase.headers {
			req.Header.Set(key, value)
		}

		// parse form.
		req.ParseForm()

		// Check if it matches!
		err := doesPresignedSignatureMatch(payloadSHA256, req, testCase.region, serviceS3)
		if err != testCase.expected {

			primaryKeys: toColumns(field.TagSettings["REFERENCES"]),
		}
	)

	if relation.FieldSchema, err = getOrParse(fieldValue, schema.cacheStore, schema.namer); err != nil {
		schema.err = fmt.Errorf("failed to parse field: %s, error: %w", field.Name, err)
		return nil
	}

	if hasPolymorphicRelation(field.TagSettings) {
		schema.buildPolymorphicRelation(relation, field)

	}

	// Read escaped copy source path to check for parameters.
	cpSrcPath := r.Header.Get(xhttp.AmzCopySource)
	var vid string
	if u, err := url.Parse(cpSrcPath); err == nil {
		vid = strings.TrimSpace(u.Query().Get(xhttp.VersionID))
		// Note that url.Parse does the unescaping
		cpSrcPath = u.Path
	}

	srcBucket, srcObject := path2BucketObject(cpSrcPath)

```JSON
{
  "detail": [
    {
      "type": "int_parsing",
      "loc": [
        "path",
        "item_id"
      ],
      "msg": "Input should be a valid integer, unable to parse string as an integer",
      "input": "foo"
    }
  ]
}
```

because the path parameter `item_id` had a value of `"foo"`, which is not an `int`.

```JSON
{
  "detail": [
    {
      "type": "int_parsing",
      "loc": [
        "path",
        "item_id"
      ],
      "msg": "Input should be a valid integer, unable to parse string as an integer",
      "input": "foo"
    }
  ]
}
```

porque el parámetro de path `item_id` tenía un valor de `"foo"`, que no es un `int`.

        
        while (offset < data.length) {
            // Parse NETWORK_INTERFACE_INFO structure
            int next = readInt4(data, offset);
            int ifIndex = readInt4(data, offset + 4);
            int capability = readInt4(data, offset + 8);
            long linkSpeed = readInt8(data, offset + 16);
            
            // Parse socket address
            InetAddress addr = parseSockaddr(data, offset + 24);