protected AssertionUtil() {
    }

    /**
     * Asserts that the argument is not <code>null</code>.
     *
     * @param argName
     *            The name of the argument that must not be {@code null}.
     * @param argValue
     *            The value of the argument.
     * @throws NullArgumentException
     *             If the argument is <code>null</code>.
     */

ECL0001={0} not found
ECL0008=argument[{0}] is null.
ECL0009=argument[{0}] is illegal. because {1}.
ECL0010=argument[{0}] is null or empty string.
ECL0011=argument[{0}] is null or empty array.
ECL0012=argument[{0}] is null or empty collection.
ECL0013=argument[{0}] is null or empty map.
ECL0014=argument[{0}] which is null the index of array is negative integer.
ECL0015=argument[{0}] which is null the index of array exceed the size of array[{1}].

     *
     * @return Name of the argument
     */
    public String getArgName() {
        return argName;
    }

    /**
     * Returns the message code.
     *
     * @return Message code
     */
    public String getMessageCode() {
        return messageCode;
    }

    /**
     * Returns the array of arguments.
     *
     * @return Array of arguments
     */

     *
     * @param constructor
     *            The constructor. Must not be {@literal null}.
     * @param index
     *            The position of the argument.
     * @param map
     *            A {@link Map} with type variables as keys and type arguments as values for the parameterized type. Must not be {@literal null}.

	if arg3 != nil {
		v3, err := arg3.evalNode(r, tableAlias)
		if err != nil {
			return nil, err
		}
		inferTypeForArithOp(v3)
		lenInt, ok := v3.ToInt()
		if !ok {
			err := fmt.Errorf("Incorrect type for length argument in %s", sqlFnSubstring)
			return nil, errIncorrectSQLFunctionArgumentType(err)
		}
		length = int(lenInt)
		if length < 0 {

   *   <li>{@code proxy.equals(argument)} returns true if:
   *       <ul>
   *         <li>{@code proxy} and {@code argument} are of the same type
   *         <li>and {@link AbstractInvocationHandler#equals} returns true for the {@link
   *             InvocationHandler} of {@code argument}
   *       </ul>
   *   <li>other method calls are dispatched to {@link #handleInvocation}.

        AvPair avPair = new AvPair(type, raw);

        assertEquals(type, avPair.getType(), "Type should match the constructor argument.");
        assertArrayEquals(raw, avPair.getRaw(), "Raw data should match the constructor argument.");

        // Test with another type and empty raw data
        int type2 = AvPair.MsvAvEOL;
        byte[] raw2 = new byte[] {};

    }

    @Test
    void testMessageAndCauseConstructor() {
        // Test the constructor with both message and cause arguments
        String message = "Test message with cause";
        Throwable cause = new IllegalArgumentException("Invalid argument");
        RequestTimeoutException exception = new RequestTimeoutException(message, cause);
        assertEquals(message, exception.getMessage(), "Message should match the provided string");

     */
    private final String methodName;

    /**
     * The argument types.
     */
    private final Class<?>[] argTypes;

    /**
     * Creates a {@link NoSuchMethodRuntimeException}.
     *
     * @param targetClass the target class
     * @param methodName the method name
     * @param argTypes the argument types
     * @param cause the underlying exception
     */

// arguments of [cmp.Ordered] types. There must be at least one argument.
// If T is a floating-point type and any of the arguments are NaNs,
// max will return NaN.
func max[T cmp.Ordered](x T, y ...T) T

// The min built-in function returns the smallest value of a fixed number of
// arguments of [cmp.Ordered] types. There must be at least one argument.