release13.07/framework/sql/src/org/ofbiz/sql/test/ValuesTest.java

/*
 * 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.ofbiz.sql.test;

import java.util.List;
import org.ofbiz.sql.ConstantValue;
import org.ofbiz.sql.CountAllFunction;
import org.ofbiz.sql.AggregateFunction;
import org.ofbiz.sql.FieldValue;
import org.ofbiz.sql.FunctionCall;
import org.ofbiz.sql.MathValue;
import org.ofbiz.sql.NumberValue;
import org.ofbiz.sql.ParameterValue;
import org.ofbiz.sql.StaticValue;
import org.ofbiz.sql.StringValue;
import org.ofbiz.sql.Value;

import org.ofbiz.base.lang.SourceMonitored;
import org.ofbiz.base.test.GenericTestCaseBase;

@SourceMonitored
public class ValuesTest extends GenericTestCaseBase {
    private static final FieldValue fv1 = new FieldValue("partyId");
    private static final FieldValue fv2 = new FieldValue("a", "partyId");
    private static final FieldValue fv3 = new FieldValue(null, "partyId");
    private static final FieldValue fv4 = new FieldValue(null, "firstName");
    private static final NumberValue<Long> nv1 = NumberValue.valueOf(1);
    private static final NumberValue<Double> nv2 = NumberValue.valueOf(2D);
    private static final NumberValue<Long> nv3 = NumberValue.valueOf(3);

    public ValuesTest(String name) {
        super(name);
    }

    private static <V extends Value> void basicTest(String label, Class<V> clz, V v, String defaultName, String s, V o, boolean matches) {
        if (v instanceof StaticValue) {
            assertEquals(label + ":default-name", defaultName, ((StaticValue) v).getDefaultName());
        }
        assertEquals(label + ":toString", s, v.toString());
        assertNotEquals(label + ":not-equals-this", v, ValuesTest.class);
        if (o != null) {
            if (matches) {
                assertEquals(label + ":equals", o, v);
            } else {
                assertNotEquals(label + ":not-equals", o, v);
            }
        }
        ValueVisitorRecorder visitor = new ValueVisitorRecorder();
        v.accept(visitor);
        v.accept(visitor);
        assertEquals(label + ":visited", 2, visitor.counts.remove(clz).intValue());
        assertTrue(label + ":nothing-else-visited", visitor.counts.isEmpty());
    }

    private static void countAllFunctionTest(String label, CountAllFunction v, String tableName, String s, CountAllFunction o, boolean matches) {
        assertEquals(label + ":left", tableName, v.getTableName());
        basicTest(label, CountAllFunction.class, v, "COUNT", s, o, matches);
    }

    public void testCountAllFunction() {
        CountAllFunction v1 = new CountAllFunction("a");
        countAllFunctionTest("v1", v1, "a", "COUNT(a.*)", null, false);
        CountAllFunction v2 = new CountAllFunction(null);
        countAllFunctionTest("v2", v2, null, "COUNT(*)", v1, false);
        CountAllFunction v3 = new CountAllFunction("a");
        countAllFunctionTest("v3", v3, "a", "COUNT(a.*)", v1, true);
    }

    private static void aggregateFunctionTest(String label, AggregateFunction v, String name, boolean isDistinct, FieldValue fv, String s, AggregateFunction o, boolean matches) {
        assertEquals(label + ":name", name, v.getName());
        assertEquals(label + ":left", isDistinct, v.isDistinct());
        assertEquals(label + ":field-value", fv, v.getValue());
        basicTest(label, AggregateFunction.class, v, name, s, o, matches);
    }

    public void testAggregateFunction() {
        AggregateFunction v1 = new AggregateFunction("COUNT", false, fv2);
        aggregateFunctionTest("v1", v1, "COUNT", false, fv2, "COUNT(a.partyId)", null, false);
        AggregateFunction v2 = new AggregateFunction("COUNT", true, fv2);
        aggregateFunctionTest("v2", v2, "COUNT", true, fv2, "COUNT(DISTINCT a.partyId)", v1, false);
        AggregateFunction v3 = new AggregateFunction("COUNT", true, fv1);
        aggregateFunctionTest("v3", v3, "COUNT", true, fv1, "COUNT(DISTINCT partyId)", v1, false);
        AggregateFunction v4 = new AggregateFunction("COUNT", false, fv1);
        aggregateFunctionTest("v4", v4, "COUNT", false, fv1, "COUNT(partyId)", v1, false);
        AggregateFunction v5 = new AggregateFunction("MAX", false, fv2);
        aggregateFunctionTest("v5", v5, "MAX", false, fv2, "MAX(a.partyId)", v1, false);
        AggregateFunction v6 = new AggregateFunction("COUNT", false, fv2);
        aggregateFunctionTest("v6", v6, "COUNT", false, fv2, "COUNT(a.partyId)", v1, true);
    }

    private static void fieldValueTest(String label, FieldValue v, String tableName, String fieldName, String s, FieldValue o, boolean matches) {
        assertEquals(label + ":table-name", tableName, v.getTableName());
        assertEquals(label + ":field-name", fieldName, v.getFieldName());
        basicTest(label, FieldValue.class, v, fieldName, s, o, matches);
    }

    public void testFieldValue() {
        fieldValueTest("fv1", fv1, null, "partyId", "partyId", null, false);
        fieldValueTest("fv2", fv2, "a", "partyId", "a.partyId", fv1, false);
        fieldValueTest("fv3", fv3, null, "partyId", "partyId", fv1, true);
        fieldValueTest("fv4", fv4, null, "firstName", "firstName", fv1, false);
    }

    private static void functionCallTest(String label, FunctionCall v, String name, List<? extends Value> values, String s, FunctionCall o, boolean matches) {
        assertEquals(label + ":name", name, v.getName());
        assertEquals(label + ":arg-count", values.size(), v.getArgCount());
        assertEqualsIterable(label, values, v);
        basicTest(label, FunctionCall.class, v, name, s, o, matches);
    }

    @SuppressWarnings("unchecked")
    public void testFunctionCall() {
        FunctionCall v1 = new FunctionCall("LENGTH", GenericTestCaseBase.<Value>list(nv1, nv2));
        functionCallTest("v1", v1, "LENGTH", list(nv1, nv2), "LENGTH(1, 2.0)", null, false);
        FunctionCall v2 = new FunctionCall("LENGTH", GenericTestCaseBase.<Value>list(nv1, nv3));
        functionCallTest("v2", v2, "LENGTH", list(nv1, nv3), "LENGTH(1, 3)", v1, false);
        FunctionCall v3 = new FunctionCall("LENGTH", GenericTestCaseBase.<Value>list(nv1, nv2));
        functionCallTest("v3", v3, "LENGTH", list(nv1, nv2), "LENGTH(1, 2.0)", v1, true);
        FunctionCall v4 = new FunctionCall("TRIM", GenericTestCaseBase.<Value>list(nv1, nv2));
        functionCallTest("v4", v4, "TRIM", list(nv1, nv2), "TRIM(1, 2.0)", v1, false);
    }

    private static void mathValueTest(String label, MathValue v, String op, List<? extends ConstantValue> values, String s, MathValue o, boolean matches) {
        assertEquals(label + ":op", op, v.getOp());
        assertEqualsIterable(label, values, v);
        basicTest(label, MathValue.class, v, null, s, o, matches);
    }

    @SuppressWarnings("unchecked")
    public void testMathValue() {
        MathValue v1 = new MathValue("+", GenericTestCaseBase.<ConstantValue>list(nv1, nv2));
        mathValueTest("v1", v1, "+", list(nv1, nv2), "(1 + 2.0)", null, false);
        MathValue v2 = new MathValue("+", GenericTestCaseBase.<ConstantValue>list(nv1, nv3));
        mathValueTest("v2", v2, "+", list(nv1, nv3), "(1 + 3)", v1, false);
        MathValue v3 = new MathValue("+", GenericTestCaseBase.<ConstantValue>list(nv1, nv2));
        mathValueTest("v3", v3, "+", list(nv1, nv2), "(1 + 2.0)", v1, true);
        MathValue v4 = new MathValue("-", GenericTestCaseBase.<ConstantValue>list(nv1, nv3));
        mathValueTest("v4", v4, "-", list(nv1, nv3), "(1 - 3)", v1, false);
    }

    public void testNull() {
        basicTest("null", Value.Null.class, Value.NULL, null, "NULL", null, false);
    }

    private static <N extends Number> void numberValueTest(String label, NumberValue<N> v, N n, String s, NumberValue<?> o, boolean matches) {
        assertEquals(label + ":number", n, v.getNumber());
        basicTest(label, NumberValue.class, v, null, s, o, matches);
    }

    public void testNumberValue() {
        numberValueTest("nv1", nv1, Long.valueOf(1), "1", null, false);
        numberValueTest("nv2", nv2, Double.valueOf(2), "2.0", nv1, false);
        NumberValue<Long> nv3 = NumberValue.valueOf(1);
        numberValueTest("nv3", nv3, Long.valueOf(1), "1", nv1, true);
    }

    private static void parameterValueTest(String label, ParameterValue v, String name, String s, ParameterValue o, boolean matches) {
        assertEquals(label + ":name", name, v.getName());
        basicTest(label, ParameterValue.class, v, null, s, o, matches);
    }

    public void testParameterValue() {
        ParameterValue v1 = new ParameterValue("a");
        parameterValueTest("v1", v1, "a", "?a", null, false);
        ParameterValue v2 = new ParameterValue("b");
        parameterValueTest("v2", v2, "b", "?b", v1, false);
        ParameterValue v3 = new ParameterValue("a");
        parameterValueTest("v3", v3, "a", "?a", v1, true);
    }

    private static void stringValueTest(String label, StringValue v, String string, String s, StringValue o, boolean matches) {
        assertEquals(label + ":name", string, v.getString());
        basicTest(label, StringValue.class, v, null, s, o, matches);
    }

    public void testStringValue() {
        StringValue v1 = new StringValue("foo");
        stringValueTest("v1", v1, "foo", "'foo'", null, false);
        StringValue v2 = new StringValue("b'r");
        stringValueTest("v2", v2, "b'r", "'b''r'", v1, false);
        StringValue v3 = new StringValue("foo");
        stringValueTest("v3", v3, "foo", "'foo'", v1, true);
    }

    public static class ValueVisitorRecorder extends Recorder<Class<? extends Value>> implements Value.Visitor {

        public void visit(AggregateFunction value) {
            record(AggregateFunction.class);
        }

        public void visit(FieldValue value) {
            record(FieldValue.class);
        }

        public void visit(FunctionCall value) {
            record(FunctionCall.class);
        }

        public void visit(MathValue value) {
            record(MathValue.class);
        }

        public void visit(Value.Null value) {
            record(Value.Null.class);
        }

        public void visit(NumberValue<?> value) {
            record(NumberValue.class);
        }

        public void visit(ParameterValue value) {
            record(ParameterValue.class);
        }

        public void visit(StringValue value) {
            record(StringValue.class);
        }

        public void visit(CountAllFunction value) {
            record(CountAllFunction.class);
        }
    }
}