leeonky / test-charm-java / 150

Committed 07 Mar 2025 12:58AM UTC coverage: 74.287% (-0.08%) from 74.367%

Build # 150

Build Type

push

circleci

Committed by

leeonky

Commit Message

Try to fix ci

Run Details

7919 of 10660 relevant lines covered (74.29%)

0.74 hits per line

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

92.0

/DAL-java/src/main/java/com/github/leeonky/dal/Assertions.java

package com.github.leeonky.dal;

import com.github.leeonky.dal.ast.node.ConstValueNode;
import com.github.leeonky.dal.ast.node.InputNode;
import com.github.leeonky.dal.ast.opt.Factory;
import com.github.leeonky.dal.runtime.IllegalTypeException;
import com.github.leeonky.dal.runtime.InputException;
import com.github.leeonky.dal.runtime.RuntimeContextBuilder;
import com.github.leeonky.dal.runtime.schema.Expect;
import com.github.leeonky.dal.runtime.schema.Verification;
import com.github.leeonky.dal.type.InputCode;
import com.github.leeonky.dal.type.InputValue;
import com.github.leeonky.interpreter.InterpreterException;

import java.lang.reflect.Array;
import java.util.function.Supplier;

import static com.github.leeonky.dal.ast.node.DALExpression.expression;
import static com.github.leeonky.dal.runtime.schema.Actual.actual;
import static com.github.leeonky.util.BeanClass.create;

public class Assertions {
    private final InputCode<Object> inputCode;
    public static boolean dumpInput = true;
    private DAL dal;
    private static Supplier<DAL> dalFactory = () -> DAL.getInstance("AssertD");
    private Class<?> schema;

    public static void setDalFactory(Supplier<DAL> dalFactory) {
        Assertions.dalFactory = dalFactory;
    }

    public static void dumpInput(boolean enable) {
        dumpInput = enable;
    }

    private Assertions(InputCode<Object> input) {
        inputCode = input;
    }

    public Assertions use(DAL dal) {
        this.dal = dal;
        return this;
    }

    public static Assertions expect(Object input) {
        return new Assertions((InputValue<Object>) () -> input);
    }

    public static Assertions expectRun(InputCode<Object> supplier) {
        return new Assertions(supplier);
    }

    public Assertions should(String dalExpression) {
        return should("", dalExpression);
    }

    public Assertions should(String prefix, String verification) {
        String fullCode = prefix + verification;
        try {
            return execute(() -> getDal().evaluate(inputCode, fullCode, schema));
        } catch (InterpreterException e) {
            String detailMessage = "\n" + e.show(fullCode, prefix.length()) + "\n\n" + e.getMessage();
            if (dumpInput)
                detailMessage += "\n\nThe root value was: " + getDal().getRuntimeContextBuilder().build(null).wrap(inputCode).dumpAll();
            throw new AssertionError(detailMessage);
        }
    }

    private DAL getDal() {
        if (dal == null)
            dal = dalFactory.get();
        return dal;
    }

    private Assertions execute(Runnable runnable) {
        try {
            runnable.run();
        } catch (InputException e) {
            String detailMessage = "\n" + e.getMessage();
            detailMessage += "\n\nInput code got exception: " + getDal().getRuntimeContextBuilder().build(null).wrap(e.getInputClause()).dumpAll();
            throw new AssertionError(detailMessage);
        }
        return this;
    }

    public void exact(String verification) {
        should("=", verification);
    }

    public void match(String verification) {
        should(":", verification);
    }

    public Assertions is(Class<?> schema) {
        RuntimeContextBuilder.DALRuntimeContext context = getDal().getRuntimeContextBuilder().build(inputCode, schema);
        try {
            this.schema = schema;
            return execute(() -> Verification.expect(new Expect(create((Class) schema), null))
                    .verify(context, actual(context.getThis())));
        } catch (IllegalTypeException e) {
            String detailMessage = "\n" + e.getMessage();
            if (dumpInput)
                detailMessage += "\n\nThe root value was: " + getDal().getRuntimeContextBuilder().build(null).wrap(inputCode).dumpAll();
            throw new AssertionError(detailMessage);
        }
    }

    public Assertions is(String schema) {
        if (schema.startsWith("[") && schema.endsWith("]"))
            return is(Array.newInstance(getDal().getRuntimeContextBuilder().schemaType(
                    schema.replace('[', ' ').replace(']', ' ').trim()).getType(), 0).getClass());
        return is(getDal().getRuntimeContextBuilder().schemaType(schema).getType());
    }

    public Assertions isEqualTo(Object expect) {
        return execute(() -> expression(InputNode.INPUT_NODE, Factory.equal(), new ConstValueNode(expect))
                .evaluate(getDal().getRuntimeContextBuilder().build(inputCode)));
    }
}

1	package com.github.leeonky.dal;
2
3	import com.github.leeonky.dal.ast.node.ConstValueNode;
4	import com.github.leeonky.dal.ast.node.InputNode;
5	import com.github.leeonky.dal.ast.opt.Factory;
6	import com.github.leeonky.dal.runtime.IllegalTypeException;
7	import com.github.leeonky.dal.runtime.InputException;
8	import com.github.leeonky.dal.runtime.RuntimeContextBuilder;
9	import com.github.leeonky.dal.runtime.schema.Expect;
10	import com.github.leeonky.dal.runtime.schema.Verification;
11	import com.github.leeonky.dal.type.InputCode;
12	import com.github.leeonky.dal.type.InputValue;
13	import com.github.leeonky.interpreter.InterpreterException;
14
15	import java.lang.reflect.Array;
16	import java.util.function.Supplier;
17
18	import static com.github.leeonky.dal.ast.node.DALExpression.expression;
19	import static com.github.leeonky.dal.runtime.schema.Actual.actual;
20	import static com.github.leeonky.util.BeanClass.create;
21
22	public class Assertions {
23	private final InputCode<Object> inputCode;
24	public static boolean dumpInput = true;	1✔
25	private DAL dal;
26	private static Supplier<DAL> dalFactory = () -> DAL.getInstance("AssertD");	1✔
27	private Class<?> schema;
28
29	public static void setDalFactory(Supplier<DAL> dalFactory) {
30	Assertions.dalFactory = dalFactory;	×
31	}	×
32
33	public static void dumpInput(boolean enable) {
34	dumpInput = enable;	1✔
35	}	1✔
36
37	private Assertions(InputCode<Object> input) {	1✔
38	inputCode = input;	1✔
39	}	1✔
40
41	public Assertions use(DAL dal) {
42	this.dal = dal;	1✔
43	return this;	1✔
44	}
45
46	public static Assertions expect(Object input) {
47	return new Assertions((InputValue<Object>) () -> input);	1✔
48	}
49
50	public static Assertions expectRun(InputCode<Object> supplier) {
51	return new Assertions(supplier);	1✔
52	}
53
54	public Assertions should(String dalExpression) {
55	return should("", dalExpression);	1✔
56	}
57
58	public Assertions should(String prefix, String verification) {
59	String fullCode = prefix + verification;	1✔
60	try {
61	return execute(() -> getDal().evaluate(inputCode, fullCode, schema));	1✔
62	} catch (InterpreterException e) {	1✔
63	String detailMessage = "\n" + e.show(fullCode, prefix.length()) + "\n\n" + e.getMessage();	1✔
64	if (dumpInput)	1✔
65	detailMessage += "\n\nThe root value was: " + getDal().getRuntimeContextBuilder().build(null).wrap(inputCode).dumpAll();	1✔
66	throw new AssertionError(detailMessage);	1✔
67	}
68	}
69
70	private DAL getDal() {
71	if (dal == null)	1✔
72	dal = dalFactory.get();	1✔
73	return dal;	1✔
74	}
75
76	private Assertions execute(Runnable runnable) {
77	try {
78	runnable.run();	1✔
79	} catch (InputException e) {	1✔
80	String detailMessage = "\n" + e.getMessage();	1✔
81	detailMessage += "\n\nInput code got exception: " + getDal().getRuntimeContextBuilder().build(null).wrap(e.getInputClause()).dumpAll();	1✔
82	throw new AssertionError(detailMessage);	1✔
83	}	1✔
84	return this;	1✔
85	}
86
87	public void exact(String verification) {
88	should("=", verification);	1✔
89	}	1✔
90
91	public void match(String verification) {
92	should(":", verification);	1✔
93	}	1✔
94
95	public Assertions is(Class<?> schema) {
96	RuntimeContextBuilder.DALRuntimeContext context = getDal().getRuntimeContextBuilder().build(inputCode, schema);	1✔
97	try {
98	this.schema = schema;	1✔
99	return execute(() -> Verification.expect(new Expect(create((Class) schema), null))	1✔
100	.verify(context, actual(context.getThis())));	1✔
101	} catch (IllegalTypeException e) {	1✔
102	String detailMessage = "\n" + e.getMessage();	1✔
103	if (dumpInput)	1✔
104	detailMessage += "\n\nThe root value was: " + getDal().getRuntimeContextBuilder().build(null).wrap(inputCode).dumpAll();	1✔
105	throw new AssertionError(detailMessage);	1✔
106	}
107	}
108
109	public Assertions is(String schema) {
110	if (schema.startsWith("[") && schema.endsWith("]"))	1✔
111	return is(Array.newInstance(getDal().getRuntimeContextBuilder().schemaType(	1✔
112	schema.replace('[', ' ').replace(']', ' ').trim()).getType(), 0).getClass());	1✔
113	return is(getDal().getRuntimeContextBuilder().schemaType(schema).getType());	1✔
114	}
115
116	public Assertions isEqualTo(Object expect) {
117	return execute(() -> expression(InputNode.INPUT_NODE, Factory.equal(), new ConstValueNode(expect))	×
118	.evaluate(getDal().getRuntimeContextBuilder().build(inputCode)));	×
119	}
120	}

leeonky / test-charm-java / 150

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