message:    "Did not find the expected left parenthesis after CAST in the SQL expression.",
		statusCode: 400,
		cause:      err,
	}
}

func errParseExpectedLeftParenValueConstructor(err error) *s3Error {
	return &s3Error{
		code:       "ParseExpectedLeftParenValueConstructor",
		message:    "Did not find expected the left parenthesis in the SQL expression.",
		statusCode: 400,
		cause:      err,
	}

}

// LiteralList is a type for parsed SQL lists literals
type LiteralList []string

// Capture interface used by participle
func (ls *LiteralList) Capture(values []string) error {
	// Remove enclosing parenthesis.
	n := len(values[0])
	r := values[0][1 : n-1]
	// Translate doubled quotes
	*ls = LiteralList(strings.Split(r, ","))
	return nil
}

// ObjectKey is a type for parsed strings occurring in key paths

		tokens = append(tokens, substitution...)
	}
	in.Push(NewSlice(in.Base(), in.Line(), tokens))
}

// argsFor returns a map from formal name to actual value for this argumented macro invocation.
// The opening parenthesis has been absorbed.
func (in *Input) argsFor(macro *Macro) map[string][]Token {
	var args [][]Token
	// One macro argument per iteration. Collect them all and check counts afterwards.
	for argNum := 0; ; argNum++ {

		haveConstant = true
	case '(':
		// Could be parenthesized expression or (R). Must be something, though.
		tok := p.next()
		if tok.ScanToken == scanner.EOF {
			p.errorf("missing right parenthesis")
			return
		}
		rname := tok.String()
		p.back()
		haveConstant = !p.atStartOfRegister(rname)
		if !haveConstant {
			p.back() // Put back the '('.
		}
	}
	if haveConstant {
		p.back()

 * side, this yields nine basic types of ranges, enumerated below. (Notation: a square bracket
 * ({@code [ ]}) indicates that the range is closed on that side; a parenthesis ({@code ( )}) means
 * it is either open or unbounded. The construct {@code {x | statement}} is read "the set of all
 * <i>x</i> such that <i>statement</i>.")
 *
 * <blockquote>
 *
 * <table>

 * side, this yields nine basic types of ranges, enumerated below. (Notation: a square bracket
 * ({@code [ ]}) indicates that the range is closed on that side; a parenthesis ({@code ( )}) means
 * it is either open or unbounded. The construct {@code {x | statement}} is read "the set of all
 * <i>x</i> such that <i>statement</i>.")
 *
 * <blockquote>
 *
 * <table>

    }

    @Test
    public void test_escapeLDAPSearchFilter_withParentheses() {
        LdapManager ldapManager = new LdapManager();
        ldapManager.init();

        // Parentheses should be escaped (prevents filter injection)
        assertEquals("\\28", ldapManager.escapeLDAPSearchFilter("("));
        assertEquals("\\29", ldapManager.escapeLDAPSearchFilter(")"));

        }
        return baseQuery + " sort:" + sortField;
    }

    /**
     * Appends a query string to the query buffer with proper formatting.
     * Handles OR operators and wraps complex queries in parentheses when necessary.
     *
     * @param queryBuf the StringBuilder to append to
     * @param query the query string to append
     */
    protected void appendQuery(final StringBuilder queryBuf, final String query) {

  @CanIgnoreReturnValue
  public B named(String name) {
    checkArgument(
        !name.contains("("),
        "Eclipse hides all characters after "
            + "'('; please use '[]' or other characters instead of parentheses");
    this.name = name;
    return self();
  }

  public String getName() {
    return name;
  }

  // Test suppression

  private final Set<Method> suppressedTests = new HashSet<>();

Le das a `Depends` un solo parámetro.

Este parámetro debe ser algo como una función.

**No la llames** directamente (no agregues los paréntesis al final), solo pásala como un parámetro a `Depends()`.

Y esa función toma parámetros de la misma manera que las *path operation functions*.

/// tip | Consejo