ExpressionAssert

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.expression;

import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dal.VariableSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BetweenExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.BinaryOperationExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.CaseWhenExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.CollateExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExistsSubqueryExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExtractArgExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.InExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.IntervalExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.KeyValueSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ListExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.NotExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.QuantifySubqueryExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.RowExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.TypeCastExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.UnaryOperationExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ValuesExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.CommonExpressionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.complex.ComplexExpressionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.LiteralExpressionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.interval.IntervalDayToSecondExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.interval.IntervalYearToMonthExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.AggregationProjectionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ExpressionProjectionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.IntervalExpressionProjection;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.join.OuterJoinExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.json.JsonNullClauseSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.multiset.MultisetExpression;
import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.xml.XmlQueryAndExistsFunctionSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.DataTypeSegment;
import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.match.MatchAgainstExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.SQLCaseAssertContext;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.SQLSegmentAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.column.ColumnAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.column.OuterJoinExpressionAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.generic.DataTypeAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.insert.InsertValuesClauseAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.owner.OwnerAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.segment.projection.ProjectionAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.asserts.statement.dml.standard.type.SelectStatementAssert;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedBetweenExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedBinaryOperationExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedCaseWhenExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedCollateExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedExistsSubquery;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedExtractArgExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedInExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedIntervalDayToSecondExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedIntervalExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedIntervalExpressionProjection;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedIntervalYearToMonthExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedKeyValueSegment;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedListExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedMatchExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedMultisetExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedNotExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedQuantifySubqueryExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedRowExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedTypeCastExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedUnaryOperationExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedValuesExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.ExpectedVariableSegment;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.complex.ExpectedCommonExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.simple.ExpectedLiteralExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.simple.ExpectedParameterMarkerExpression;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.expr.simple.ExpectedSubquery;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.function.ExpectedFunction;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.json.ExpectedJsonNullClauseSegment;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.xmlquery.ExpectedXmlQueryAndExistsFunctionSegment;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.sql.type.SQLCaseType;

import java.util.Iterator;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Expression assert.
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class ExpressionAssert {

    /**
     * Assert parameter marker expression.
     *
     * @param assertContext assert context
     * @param actual actual parameter marker expression segment
     * @param expected expected parameter marker expression
     */
    public static void assertParameterMarkerExpression(final SQLCaseAssertContext assertContext,
                                                       final ParameterMarkerExpressionSegment actual, final ExpectedParameterMarkerExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual parameter marker expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual parameter marker expression should exist."));
            assertThat(assertContext.getText("Parameter marker index assertion error: "), actual.getParameterMarkerIndex(), is(expected.getParameterIndex()));
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert literal expression.
     *
     * @param assertContext assert context
     * @param actual actual literal expression segment
     * @param expected expected literal expression
     */
    public static void assertLiteralExpression(final SQLCaseAssertContext assertContext,
                                               final LiteralExpressionSegment actual, final ExpectedLiteralExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual literal expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual literal expression should exist."));
            assertThat(assertContext.getText("Literal assertion error: "), String.valueOf(actual.getLiterals()), is(expected.getValue()));
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert common expression.
     *
     * @param assertContext assert context
     * @param actual actual common expression segment
     * @param expected expected common expression
     */
    public static void assertCommonExpression(final SQLCaseAssertContext assertContext,
                                              final ComplexExpressionSegment actual, final ExpectedCommonExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual common expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual common expression should exist."));
            String expectedText = SQLCaseType.LITERAL == assertContext.getCaseType() && null != expected.getLiteralText() ? expected.getLiteralText() : expected.getText();
            assertThat(assertContext.getText("Common expression text assertion error: "), actual.getText(), is(expectedText));
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert subquery expression.
     *
     * @param assertContext assert context
     * @param actual actual subquery expression segment
     * @param expected expected subquery expression
     */
    public static void assertSubqueryExpression(final SQLCaseAssertContext assertContext,
                                                final SubqueryExpressionSegment actual, final ExpectedSubquery expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual subquery expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual subquery expression should exist."));
            assertSubquery(assertContext, actual.getSubquery(), expected);
        }
    }

    /**
     * Assert subquery.
     *
     * @param assertContext assert context
     * @param actual actual subquery segment
     * @param expected expected subquery expression
     */
    public static void assertSubquery(final SQLCaseAssertContext assertContext,
                                      final SubquerySegment actual, final ExpectedSubquery expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual subquery should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual subquery should exist."));
            SelectStatementAssert.assertIs(assertContext, actual.getSelect(), expected.getSelectTestCases());
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert exists subquery expression.
     *
     * @param assertContext assert context
     * @param actual actual exists subquery expression
     * @param expected expected exists subquery expression
     */
    public static void assertExistsSubqueryExpression(final SQLCaseAssertContext assertContext,
                                                      final ExistsSubqueryExpression actual, final ExpectedExistsSubquery expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual exists subquery should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual exists subquery should exist."));
            assertSubquery(assertContext, actual.getSubquery(), expected.getSubquery());
            assertThat(assertContext.getText("Exists subquery expression not value assert error."),
                    actual.isNot(), is(expected.isNot()));
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert binary operation expression.
     *
     * @param assertContext assert context
     * @param actual actual binary operation expression
     * @param expected expected binary operation expression
     */
    public static void assertBinaryOperationExpression(final SQLCaseAssertContext assertContext,
                                                       final BinaryOperationExpression actual, final ExpectedBinaryOperationExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual binary operation expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual binary operation expression should exist."));
            assertExpression(assertContext, actual.getLeft(), expected.getLeft());
            assertThat(assertContext.getText("Binary operation expression operator assert error."),
                    actual.getOperator(), is(expected.getOperator()));
            assertExpression(assertContext, actual.getRight(), expected.getRight());
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert in operation expression.
     *
     * @param assertContext assert context
     * @param actual actual in operation expression
     * @param expected expected in operation expression
     */
    public static void assertInExpression(final SQLCaseAssertContext assertContext,
                                          final InExpression actual, final ExpectedInExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual in expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual in expression should exist."));
            assertExpression(assertContext, actual.getLeft(), expected.getLeft());
            assertThat(assertContext.getText("In expression not value assert error."),
                    actual.isNot(), is(expected.isNot()));
            assertExpression(assertContext, actual.getRight(), expected.getRight());
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert not operation expression.
     *
     * @param assertContext assert context
     * @param actual actual not operation expression
     * @param expected expected not operation expression
     */
    public static void assertNotExpression(final SQLCaseAssertContext assertContext,
                                           final NotExpression actual, final ExpectedNotExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual not expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual not expression should exist."));
            assertExpression(assertContext, actual.getExpression(), expected.getExpr());
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert list operation expression.
     *
     * @param assertContext assert context
     * @param actual actual list operation expression
     * @param expected expected list operation expression
     */
    public static void assertListExpression(final SQLCaseAssertContext assertContext,
                                            final ListExpression actual, final ExpectedListExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual list expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual list expression should exist."));
            assertThat(assertContext.getText("List expression item size assert error."),
                    actual.getItems().size(), is(expected.getItems().size()));
            Iterator<ExpressionSegment> actualItems = actual.getItems().iterator();
            Iterator<ExpectedExpression> expectedItems = expected.getItems().iterator();
            while (actualItems.hasNext()) {
                assertExpression(assertContext, actualItems.next(), expectedItems.next());
            }
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert between operation expression.
     *
     * @param assertContext assert context
     * @param actual actual between operation expression
     * @param expected expected between operation expression
     */
    public static void assertBetweenExpression(final SQLCaseAssertContext assertContext,
                                               final BetweenExpression actual, final ExpectedBetweenExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual between expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual between expression should exist."));
            assertExpression(assertContext, actual.getLeft(), expected.getLeft());
            assertExpression(assertContext, actual.getBetweenExpr(), expected.getBetweenExpr());
            assertExpression(assertContext, actual.getAndExpr(), expected.getAndExpr());
            assertThat(assertContext.getText("Between expression not value assert error."),
                    actual.isNot(), is(expected.isNot()));
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert function.
     *
     * @param assertContext assert context
     * @param actual actual function segment
     * @param expected expected function segment
     */
    public static void assertFunction(final SQLCaseAssertContext assertContext, final FunctionSegment actual, final ExpectedFunction expected) {
        SQLSegmentAssert.assertIs(assertContext, actual, expected);
        assertThat(assertContext.getText("Function method name assertion error: "), actual.getFunctionName(), is(expected.getFunctionName()));
        String expectedText = SQLCaseType.LITERAL == assertContext.getCaseType() && null != expected.getLiteralText()
                ? expected.getLiteralText()
                : expected.getText();
        assertThat(assertContext.getText("Function text name assertion error: "), actual.getText(), is(expectedText));
        assertThat(assertContext.getText("Function parameter size assertion error: "), actual.getParameters().size(), is(expected.getParameters().size()));
        Iterator<ExpectedExpression> expectedIterator = expected.getParameters().iterator();
        Iterator<ExpressionSegment> actualIterator = actual.getParameters().iterator();
        while (expectedIterator.hasNext()) {
            assertExpression(assertContext, actualIterator.next(), expectedIterator.next());
        }
        if (null != expected.getOwner()) {
            OwnerAssert.assertIs(assertContext, actual.getOwner(), expected.getOwner());
        }
    }

    /**
     * Assert collate.
     *
     * @param assertContext assert context
     * @param actual actual collate expression
     * @param expected expected collate expression
     */
    public static void assertCollateExpression(final SQLCaseAssertContext assertContext, final CollateExpression actual, final ExpectedCollateExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual collate expression should not exist."));
        } else {
            assertExpression(assertContext, actual.getCollateName(), expected.getCollateName());
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert case when expression.
     *
     * @param assertContext assert context
     * @param actual actual case when expression
     * @param expected expected case when expression
     */
    public static void assertCaseWhenExpression(final SQLCaseAssertContext assertContext, final CaseWhenExpression actual, final ExpectedCaseWhenExpression expected) {
        assertThat(assertContext.getText("When exprs size is not same!"), actual.getWhenExprs().size(), is(expected.getWhenExprs().size()));
        assertThat(assertContext.getText("Then exprs size is not same!"), actual.getThenExprs().size(), is(expected.getThenExprs().size()));
        Iterator<ExpectedExpression> whenExprsIterator = expected.getWhenExprs().iterator();
        for (ExpressionSegment each : actual.getWhenExprs()) {
            assertExpression(assertContext, each, whenExprsIterator.next());
        }
        Iterator<ExpectedExpression> thenExprsIterator = expected.getThenExprs().iterator();
        for (ExpressionSegment each : actual.getThenExprs()) {
            assertExpression(assertContext, each, thenExprsIterator.next());
        }
        assertExpression(assertContext, actual.getCaseExpr(), expected.getCaseExpr());
        assertExpression(assertContext, actual.getElseExpr(), expected.getElseExpr());
    }

    private static void assertTypeCastExpression(final SQLCaseAssertContext assertContext, final TypeCastExpression actual, final ExpectedTypeCastExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Type cast expression should not exist."));
            return;
        }
        assertNotNull(actual, assertContext.getText("Type cast expression is expected."));
        assertThat(assertContext.getText("Actual data type is different with expected in type case expression."), actual.getDataType(), is(expected.getDataType()));
        assertExpression(assertContext, actual.getExpression(), expected.getExpression());
    }

    private static void assertVariableSegment(final SQLCaseAssertContext assertContext, final VariableSegment actual, final ExpectedVariableSegment expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Variable segment should not exist."));
            return;
        }
        assertThat(assertContext.getText("Actual scope is different with expected scope."), actual.getScope().orElse(null), is(expected.getScope()));
        assertThat(assertContext.getText("Actual variable is different with expected variable."), actual.getVariable(), is(expected.getVariable()));
    }

    private static void assertValuesExpression(final SQLCaseAssertContext assertContext, final ValuesExpression actual, final ExpectedValuesExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Values segment should not exist."));
            return;
        }
        assertNotNull(actual, assertContext.getText("Values segment should exist."));
        if (null == expected.getInsertValuesClause()) {
            assertTrue(actual.getRowConstructorList().isEmpty(), "Values expression should not exist.");
        } else {
            assertFalse(actual.getRowConstructorList().isEmpty(), assertContext.getText("Values expression should exist."));
            InsertValuesClauseAssert.assertIs(assertContext, actual.getRowConstructorList(), expected.getInsertValuesClause());
        }
    }

    /**
     * Assert extract arg expression.
     *
     * @param assertContext assert context
     * @param actual actual extract arg expression
     * @param expected expected extract arg expression
     */
    private static void assertExtractArgExpression(final SQLCaseAssertContext assertContext, final ExtractArgExpression actual, final ExpectedExtractArgExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Extract arg expression should not exist."));
            return;
        }
        assertThat(assertContext.getText("Extract arg expression assertion error: "), actual.getText(), is(expected.getText()));
    }

    private static void assertMatchSegment(final SQLCaseAssertContext assertContext, final MatchAgainstExpression actual, final ExpectedMatchExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual match expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual match expression should exist"));
            assertExpression(assertContext, actual.getExpr(), expected.getExpr());
        }
    }

    private static void assertIntervalExpression(final SQLCaseAssertContext assertContext, final IntervalExpression actual, final ExpectedIntervalExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual interval expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual interval expression should exist"));
            assertExpression(assertContext, actual.getValue(), expected.getValue());
            assertThat(assertContext.getText("Actual interval unit is different with expected interval unit."), actual.getIntervalUnit(), is(expected.getIntervalUnit()));
        }
    }

    /**
     * Assert expression by actual expression segment class type.
     *
     * @param assertContext assert context
     * @param actual actual interval expression
     * @param expected expected interval expression
     */
    private static void assertIntervalExpression(final SQLCaseAssertContext assertContext, final IntervalExpressionProjection actual, final ExpectedIntervalExpressionProjection expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual interval expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual interval expression should exist"));
            assertExpression(assertContext, actual.getLeft(), expected.getLeft());
            assertExpression(assertContext, actual.getRight(), expected.getRight());
            assertExpression(assertContext, actual.getMinus(), expected.getOperator());
            if (null != actual.getDayToSecondExpression()) {
                assertIntervalDayToSecondExpression(assertContext, actual.getDayToSecondExpression(), expected.getDayToSecondExpression());
            } else {
                assertIntervalYearToMonthExpression(assertContext, actual.getYearToMonthExpression(), expected.getYearToMonthExpression());
            }
        }
    }

    private static void assertQuantifySubqueryExpression(final SQLCaseAssertContext assertContext, final QuantifySubqueryExpression actual, final ExpectedQuantifySubqueryExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual quantify subquery expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual quantify subquery expression should exist."));
            assertThat(assertContext.getText("Quantify operator assertion error: "), actual.getQuantifyOperator(), is(expected.getOperator()));
            assertSubquery(assertContext, actual.getSubquery(), expected.getSubquery());
        }
    }

    /**
     * Assert expression by actual expression segment class type.
     *
     * @param assertContext assert context
     * @param actual actual interval day to second expression
     * @param expected expected interval day to second expression
     */
    private static void assertIntervalDayToSecondExpression(final SQLCaseAssertContext assertContext,
                                                            final IntervalDayToSecondExpression actual, final ExpectedIntervalDayToSecondExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual interval expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual interval expression should exist"));
            if (null != actual.getLeadingFieldPrecision()) {
                assertThat(actual.getLeadingFieldPrecision(), is(expected.getLeadingFieldPrecision()));
            } else {
                assertNull(expected.getLeadingFieldPrecision(), assertContext.getText("Actual leading field precision should not exist."));
            }
            if (null != actual.getFractionalSecondPrecision()) {
                assertThat(actual.getFractionalSecondPrecision(), is(expected.getFractionalSecondPrecision()));
            } else {
                assertThat(expected.getFractionalSecondPrecision(), is(assertContext.getText("Actual fractional second precision should not exist.")));
            }
        }
    }

    /**
     * Assert expression by actual expression segment class type.
     *
     * @param assertContext assert context
     * @param actual actual interval year to month expression
     * @param expected expected interval year to month expression
     */
    private static void assertIntervalYearToMonthExpression(final SQLCaseAssertContext assertContext,
                                                            final IntervalYearToMonthExpression actual, final ExpectedIntervalYearToMonthExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual interval expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual interval expression should exist"));
            if (null != actual.getLeadingFieldPrecision()) {
                assertThat(actual.getLeadingFieldPrecision(), is(expected.getLeadingFieldPrecision()));
            } else {
                assertNull(expected.getLeadingFieldPrecision(), assertContext.getText("Actual leading field precision should not exist."));
            }
        }
    }

    private static void assertMultisetExpression(final SQLCaseAssertContext assertContext, final MultisetExpression actual, final ExpectedMultisetExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Multiset expression should not exist."));
            return;
        }
        assertNotNull(actual, assertContext.getText("Multiset expression should exist."));
        assertExpression(assertContext, actual.getLeft(), expected.getLeft());
        assertExpression(assertContext, actual.getRight(), expected.getRight());
        assertThat(assertContext.getText("Multiset operator assertion error: "), actual.getOperator(), is(expected.getOperator()));
        assertThat(assertContext.getText("Multiset keyword assertion error: "), actual.getKeyWord(), is(expected.getKeyWord()));
    }

    /**
     * Assert row expression.
     *
     * @param assertContext assert context
     * @param actual actual row expression
     * @param expected expected row expression
     */
    private static void assertRowExpression(final SQLCaseAssertContext assertContext, final RowExpression actual, final ExpectedRowExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Row expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual list expression should not exist."));
            assertThat(assertContext.getText("Row expression item size assert error."),
                    actual.getItems().size(), is(expected.getItems().size()));
            Iterator<ExpressionSegment> actualItems = actual.getItems().iterator();
            Iterator<ExpectedExpression> expectedItems = expected.getItems().iterator();
            while (actualItems.hasNext()) {
                assertExpression(assertContext, actualItems.next(), expectedItems.next());
            }
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert unary operation expression.
     *
     * @param assertContext assert context
     * @param actual actual unary operation expression
     * @param expected expected unary operation expression
     */
    private static void assertUnaryOperationExpression(final SQLCaseAssertContext assertContext, final UnaryOperationExpression actual, final ExpectedUnaryOperationExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual unary operation expression should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual unary operation expression should exist."));
            assertExpression(assertContext, actual.getExpression(), expected.getExpr());
            assertThat(assertContext.getText("Unary operation expression operator assert error."),
                    actual.getOperator(), is(expected.getOperator()));
            SQLSegmentAssert.assertIs(assertContext, actual, expected);
        }
    }

    /**
     * Assert xml query and exists function segment.
     *
     * @param assertContext assert context
     * @param actual actual xml query and exists function segment
     * @param expected expected xml query and exists function segment
     */
    private static void assertXmlQueryAndExistsFunctionSegment(final SQLCaseAssertContext assertContext, final XmlQueryAndExistsFunctionSegment actual,
                                                               final ExpectedXmlQueryAndExistsFunctionSegment expected) {
        assertThat(assertContext.getText("function name assertion error"), actual.getFunctionName(), is(expected.getFunctionName()));
        assertThat(assertContext.getText("xquery string assertion error"), actual.getXQueryString(), is(expected.getXQueryString()));
        assertThat(assertContext.getText("parameter size assertion error: "), actual.getParameters().size(), is(expected.getParameters().size()));
        Iterator<ExpectedExpression> expectedIterator = expected.getParameters().iterator();
        Iterator<ExpressionSegment> actualIterator = actual.getParameters().iterator();
        while (expectedIterator.hasNext()) {
            assertExpression(assertContext, actualIterator.next(), expectedIterator.next());
        }
    }

    /**
     * Assert key value segment.
     *
     * @param assertContext assert context
     * @param actual actual key value segment
     * @param expected expected key value segment
     */
    private static void assertKeyValueSegment(final SQLCaseAssertContext assertContext, final KeyValueSegment actual, final ExpectedKeyValueSegment expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual key value should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual key value should exist."));
            assertExpression(assertContext, actual.getKey(), expected.getKey());
            assertExpression(assertContext, actual.getValue(), expected.getValue());
        }
    }

    /**
     * Assert json null clause segment.
     *
     * @param assertContext assert context
     * @param actual actual json null clause segment
     * @param expected expected json null clause segment
     */
    private static void assertJsonNullClauseSegment(final SQLCaseAssertContext assertContext, final JsonNullClauseSegment actual, final ExpectedJsonNullClauseSegment expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual json null clause should not exist."));
        } else {
            assertNotNull(actual, assertContext.getText("Actual json null clause should exist."));
            assertThat(assertContext.getText("Json null clause assertion error."), actual.getText(), is(expected.getText()));
        }
    }

    /**
     * Assert expression by actual expression segment class type.
     *
     * @param assertContext assert context
     * @param actual actual expression segment
     * @param expected expected expression
     * @throws UnsupportedOperationException When expression segment class type is not supported.
     */
    public static void assertExpression(final SQLCaseAssertContext assertContext,
                                        final ExpressionSegment actual, final ExpectedExpression expected) {
        if (null == expected) {
            assertNull(actual, assertContext.getText("Actual expression should not exist."));
            return;
        }
        assertNotNull(actual, assertContext.getText("Actual expression should exist."));
        if (actual instanceof BinaryOperationExpression) {
            assertBinaryOperationExpression(assertContext, (BinaryOperationExpression) actual, expected.getBinaryOperationExpression());
        } else if (actual instanceof SubqueryExpressionSegment) {
            assertSubqueryExpression(assertContext, (SubqueryExpressionSegment) actual, expected.getSubquery());
        } else if (actual instanceof ColumnSegment) {
            ColumnAssert.assertIs(assertContext, (ColumnSegment) actual, expected.getColumn());
        } else if (actual instanceof DataTypeSegment) {
            DataTypeAssert.assertIs(assertContext, (DataTypeSegment) actual, expected.getDataType());
        } else if (actual instanceof LiteralExpressionSegment) {
            assertLiteralExpression(assertContext, (LiteralExpressionSegment) actual, expected.getLiteralExpression());
        } else if (actual instanceof ParameterMarkerExpressionSegment) {
            assertParameterMarkerExpression(assertContext, (ParameterMarkerExpressionSegment) actual, expected.getParameterMarkerExpression());
        } else if (actual instanceof ExistsSubqueryExpression) {
            assertExistsSubqueryExpression(assertContext, (ExistsSubqueryExpression) actual, expected.getExistsSubquery());
        } else if (actual instanceof CommonExpressionSegment) {
            assertCommonExpression(assertContext, (ComplexExpressionSegment) actual, expected.getCommonExpression());
        } else if (actual instanceof InExpression) {
            assertInExpression(assertContext, (InExpression) actual, expected.getInExpression());
        } else if (actual instanceof NotExpression) {
            assertNotExpression(assertContext, (NotExpression) actual, expected.getNotExpression());
        } else if (actual instanceof ListExpression) {
            assertListExpression(assertContext, (ListExpression) actual, expected.getListExpression());
        } else if (actual instanceof BetweenExpression) {
            assertBetweenExpression(assertContext, (BetweenExpression) actual, expected.getBetweenExpression());
        } else if (actual instanceof ExpressionProjectionSegment) {
            ProjectionAssert.assertProjection(assertContext, (ExpressionProjectionSegment) actual, expected.getExpressionProjection());
        } else if (actual instanceof AggregationProjectionSegment) {
            ProjectionAssert.assertProjection(assertContext, (AggregationProjectionSegment) actual, expected.getAggregationProjection());
        } else if (actual instanceof FunctionSegment) {
            assertFunction(assertContext, (FunctionSegment) actual, expected.getFunction());
        } else if (actual instanceof CollateExpression) {
            assertCollateExpression(assertContext, (CollateExpression) actual, expected.getCollateExpression());
        } else if (actual instanceof CaseWhenExpression) {
            assertCaseWhenExpression(assertContext, (CaseWhenExpression) actual, expected.getCaseWhenExpression());
        } else if (actual instanceof TypeCastExpression) {
            assertTypeCastExpression(assertContext, (TypeCastExpression) actual, expected.getTypeCastExpression());
        } else if (actual instanceof VariableSegment) {
            assertVariableSegment(assertContext, (VariableSegment) actual, expected.getVariableSegment());
        } else if (actual instanceof ValuesExpression) {
            assertValuesExpression(assertContext, (ValuesExpression) actual, expected.getValuesExpression());
        } else if (actual instanceof ExtractArgExpression) {
            assertExtractArgExpression(assertContext, (ExtractArgExpression) actual, expected.getExtractArgExpression());
        } else if (actual instanceof MatchAgainstExpression) {
            assertMatchSegment(assertContext, (MatchAgainstExpression) actual, expected.getMatchExpression());
        } else if (actual instanceof OuterJoinExpression) {
            OuterJoinExpressionAssert.assertIs(assertContext, (OuterJoinExpression) actual, expected.getOuterJoinExpression());
        } else if (actual instanceof IntervalExpressionProjection) {
            assertIntervalExpression(assertContext, (IntervalExpressionProjection) actual, expected.getIntervalExpressionProjection());
        } else if (actual instanceof MultisetExpression) {
            assertMultisetExpression(assertContext, (MultisetExpression) actual, expected.getMultisetExpression());
        } else if (actual instanceof RowExpression) {
            assertRowExpression(assertContext, (RowExpression) actual, expected.getRowExpression());
        } else if (actual instanceof UnaryOperationExpression) {
            assertUnaryOperationExpression(assertContext, (UnaryOperationExpression) actual, expected.getUnaryOperationExpression());
        } else if (actual instanceof XmlQueryAndExistsFunctionSegment) {
            assertXmlQueryAndExistsFunctionSegment(assertContext, (XmlQueryAndExistsFunctionSegment) actual, expected.getExpectedXmlQueryAndExistsFunctionSegment());
        } else if (actual instanceof KeyValueSegment) {
            assertKeyValueSegment(assertContext, (KeyValueSegment) actual, expected.getKeyValueSegment());
        } else if (actual instanceof JsonNullClauseSegment) {
            assertJsonNullClauseSegment(assertContext, (JsonNullClauseSegment) actual, expected.getJsonNullClauseSegment());
        } else if (actual instanceof IntervalExpression) {
            assertIntervalExpression(assertContext, (IntervalExpression) actual, expected.getIntervalExpression());
        } else if (actual instanceof QuantifySubqueryExpression) {
            assertQuantifySubqueryExpression(assertContext, (QuantifySubqueryExpression) actual, expected.getQuantifySubqueryExpression());
        } else {
            throw new UnsupportedOperationException(String.format("Unsupported expression: %s", actual.getClass().getName()));
        }
    }
}