leeonky / test-charm-java / 212

Committed 14 Apr 2025 05:15AM UTC coverage: 74.088% (-0.1%) from 74.209%

Build # 212

Build Type

push

circleci

Committed by

leeonky

Commit Message

Update version

Run Details

7957 of 10740 relevant lines covered (74.09%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.24

/DAL-java/src/main/java/com/github/leeonky/dal/runtime/Calculator.java

package com.github.leeonky.dal.runtime;

import com.github.leeonky.dal.ast.opt.DALOperator;
import com.github.leeonky.dal.runtime.RuntimeContextBuilder.DALRuntimeContext;
import com.github.leeonky.util.NumberType;
import com.github.leeonky.util.Pair;

import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;

import static com.github.leeonky.dal.runtime.ExpressionException.*;
import static com.github.leeonky.util.Classes.getClassName;
import static com.github.leeonky.util.Pair.pair;
import static com.github.leeonky.util.function.Extension.getFirstPresent;
import static java.lang.String.format;
import static java.util.Comparator.*;

public class Calculator {
    private static final NumberType numberType = new NumberType();

    private static int compare(Pair<Data> pair, DALRuntimeContext context) {
        return getFirstPresent(
                () -> pair.both(d -> d.cast(Number.class), (num1, num2) -> context.getNumberType().compare(num1, num2)),
                () -> pair.both(d -> d.cast(String.class), String::compareTo)).orElseThrow(() ->
                illegalOperation(pair.map(data -> dump(data.instance()), (s1, s2) -> format("Can not compare %s and %s", s1, s2))));
    }

    private static String dump(Object value) {
        return value == null ? "[null]" : format("[%s: %s]", getClassName(value), value);
    }

    public static boolean equals(Data data1, Data data2) {
        return data1.instance() == data2.instance()
                || opt2(data2::isNull) && opt1(data1::isNull)
                || (data2.isList() && data1.isList() ?
                collect(data2, "2").equals(collect(data1, "1"))
                : Objects.equals(data1.instance(), data2.instance()));
    }

    private static List<Object> collect(Data data, String index) {
        try {
            return data.list().collect();
        } catch (InfiniteCollectionException ignore) {
            throw illegalOperation("Invalid operation, operand " + index + " is infinite collection");
        }
    }

    public static Data arithmetic(Data v1, DALOperator opt, Data v2, DALRuntimeContext context) {
        return context.calculate(v1, opt, v2);
    }

    public static Data and(Supplier<Data> s1, Supplier<Data> s2) {
        Data v1 = s1.get();
        return isTrue(v1) ? s2.get() : v1;
    }

    private static boolean isTrue(Data data) {
        return getFirstPresent(() -> data.cast(Boolean.class),
                () -> data.cast(Number.class).map(number -> numberType.compare(0, number) != 0)
        ).orElseGet(() -> !data.isNull());
    }

    public static Data or(Supplier<Data> s1, Supplier<Data> s2) {
        Data v1 = s1.get();
        return isTrue(v1) ? v1 : s2.get();
    }

    public static Object not(Object v) {
        if (v instanceof Boolean)
            return !(boolean) v;
        throw illegalOperation("Operand" + " should be boolean but '" + getClassName(v) + "'");
    }

    public static Data negate(Data input, DALRuntimeContext context) {
        return input.map(value -> {
            if (value instanceof Number)
                return context.getNumberType().negate((Number) value);
            if (input.isList())
                return sortList(input.list(), reverseOrder(), context);
            throw illegalOp2(format("Operand should be number or list but '%s'", getClassName(value)));
        });
    }

    @SuppressWarnings("unchecked")
    private static Object sortList(Data.DataList list, Comparator<?> comparator, DALRuntimeContext context) {
        return list.sort(comparing(data -> context.transformComparable(data.instance()), (Comparator<Object>) comparator));
    }

    public static Data positive(Data input, DALRuntimeContext context) {
        return input.map(value -> {
            if (input.isList())
                return sortList(input.list(), naturalOrder(), context);
            throw illegalOp2(format("Operand should be list but '%s'", getClassName(input.instance())));
        });
    }

    public static Object less(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
        return compare(pair(left, right), context) < 0;
    }

    public static Object greaterOrEqual(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
        return compare(pair(left, right), context) >= 0;
    }

    public static Object lessOrEqual(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
        return compare(pair(left, right), context) <= 0;
    }

    public static Object greater(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
        return compare(pair(left, right), context) > 0;
    }

    public static boolean notEqual(Data left, Data right) {
        return !equals(left, right);
    }
}

1	package com.github.leeonky.dal.runtime;
2
3	import com.github.leeonky.dal.ast.opt.DALOperator;
4	import com.github.leeonky.dal.runtime.RuntimeContextBuilder.DALRuntimeContext;
5	import com.github.leeonky.util.NumberType;
6	import com.github.leeonky.util.Pair;
7
8	import java.util.Comparator;
9	import java.util.List;
10	import java.util.Objects;
11	import java.util.function.Supplier;
12
13	import static com.github.leeonky.dal.runtime.ExpressionException.*;
14	import static com.github.leeonky.util.Classes.getClassName;
15	import static com.github.leeonky.util.Pair.pair;
16	import static com.github.leeonky.util.function.Extension.getFirstPresent;
17	import static java.lang.String.format;
18	import static java.util.Comparator.*;
19
20	public class Calculator {	×
21	private static final NumberType numberType = new NumberType();	1✔
22
23	private static int compare(Pair<Data> pair, DALRuntimeContext context) {
24	return getFirstPresent(	1✔
25	() -> pair.both(d -> d.cast(Number.class), (num1, num2) -> context.getNumberType().compare(num1, num2)),	1✔
26	() -> pair.both(d -> d.cast(String.class), String::compareTo)).orElseThrow(() ->	1✔
27	illegalOperation(pair.map(data -> dump(data.instance()), (s1, s2) -> format("Can not compare %s and %s", s1, s2))));	1✔
28	}
29
30	private static String dump(Object value) {
31	return value == null ? "[null]" : format("[%s: %s]", getClassName(value), value);	1✔
32	}
33
34	public static boolean equals(Data data1, Data data2) {
35	return data1.instance() == data2.instance()	1✔
36	\|\| opt2(data2::isNull) && opt1(data1::isNull)	1✔
37	\|\| (data2.isList() && data1.isList() ?	1✔
38	collect(data2, "2").equals(collect(data1, "1"))	1✔
39	: Objects.equals(data1.instance(), data2.instance()));	1✔
40	}
41
42	private static List<Object> collect(Data data, String index) {
43	try {
44	return data.list().collect();	1✔
45	} catch (InfiniteCollectionException ignore) {	1✔
46	throw illegalOperation("Invalid operation, operand " + index + " is infinite collection");	1✔
47	}
48	}
49
50	public static Data arithmetic(Data v1, DALOperator opt, Data v2, DALRuntimeContext context) {
51	return context.calculate(v1, opt, v2);	1✔
52	}
53
54	public static Data and(Supplier<Data> s1, Supplier<Data> s2) {
55	Data v1 = s1.get();	1✔
56	return isTrue(v1) ? s2.get() : v1;	1✔
57	}
58
59	private static boolean isTrue(Data data) {
60	return getFirstPresent(() -> data.cast(Boolean.class),	1✔
61	() -> data.cast(Number.class).map(number -> numberType.compare(0, number) != 0)	1✔
62	).orElseGet(() -> !data.isNull());	1✔
63	}
64
65	public static Data or(Supplier<Data> s1, Supplier<Data> s2) {
66	Data v1 = s1.get();	1✔
67	return isTrue(v1) ? v1 : s2.get();	1✔
68	}
69
70	public static Object not(Object v) {
71	if (v instanceof Boolean)	1✔
72	return !(boolean) v;	1✔
73	throw illegalOperation("Operand" + " should be boolean but '" + getClassName(v) + "'");	×
74	}
75
76	public static Data negate(Data input, DALRuntimeContext context) {
77	return input.map(value -> {	1✔
78	if (value instanceof Number)	1✔
79	return context.getNumberType().negate((Number) value);	1✔
80	if (input.isList())	1✔
81	return sortList(input.list(), reverseOrder(), context);	1✔
82	throw illegalOp2(format("Operand should be number or list but '%s'", getClassName(value)));	1✔
83	});
84	}
85
86	@SuppressWarnings("unchecked")
87	private static Object sortList(Data.DataList list, Comparator<?> comparator, DALRuntimeContext context) {
88	return list.sort(comparing(data -> context.transformComparable(data.instance()), (Comparator<Object>) comparator));	1✔
89	}
90
91	public static Data positive(Data input, DALRuntimeContext context) {
92	return input.map(value -> {	1✔
93	if (input.isList())	1✔
94	return sortList(input.list(), naturalOrder(), context);	1✔
95	throw illegalOp2(format("Operand should be list but '%s'", getClassName(input.instance())));	1✔
96	});
97	}
98
99	public static Object less(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
100	return compare(pair(left, right), context) < 0;	1✔
101	}
102
103	public static Object greaterOrEqual(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
104	return compare(pair(left, right), context) >= 0;	1✔
105	}
106
107	public static Object lessOrEqual(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
108	return compare(pair(left, right), context) <= 0;	1✔
109	}
110
111	public static Object greater(Data left, DALOperator opt, Data right, DALRuntimeContext context) {
112	return compare(pair(left, right), context) > 0;	1✔
113	}
114
115	public static boolean notEqual(Data left, Data right) {
116	return !equals(left, right);	1✔
117	}
118	}

leeonky / test-charm-java / 212

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous