leeonky / test-charm-java / 252

Committed 02 Aug 2025 11:17AM UTC coverage: 74.246% (-0.01%) from 74.26%

Build # 252

Build Type

push

circleci

Committed by

leeonky

Commit Message

Update exception output

Run Details

4 of 6 new or added lines in 3 files covered. (66.67%)

8075 of 10876 relevant lines covered (74.25%)

0.74 hits per line

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

87.5

/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.Data;
import com.github.leeonky.dal.runtime.IllegalTypeException;
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.interpreter.InterpreterException;
import com.github.leeonky.util.ThrowingSupplier;

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.dal("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(() -> input);
    }

    public static Assertions expectRun(ThrowingSupplier<Object> supplier) {
        return new Assertions(supplier::get);
    }

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

    public Assertions should(String prefix, String verification) {
        String fullCode = prefix + verification;
        try {
            getDAL().evaluate(inputCode, fullCode, schema);
            return this;
        } catch (InterpreterException e) {
            String detailMessage = e.show(fullCode, prefix.length()) + "\n\n" + e.getMessage();
            if (dumpInput)
                detailMessage += "\n\nThe root value was: " + getDAL().getRuntimeContextBuilder().build(inputCode).getThis().dump();
            throw new AssertionError(detailMessage) {
                @Override
                public String toString() {
                    return AssertionError.class.getName() + ":\n" + getMessage();
                }
            };
        }
    }

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

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

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

    @SuppressWarnings("unchecked")
    public Assertions is(Class<?> schema) {
        RuntimeContextBuilder.DALRuntimeContext context = getDAL().getRuntimeContextBuilder().build(inputCode, schema);
        Data<?> input = context.getThis();
        try {
            this.schema = schema;
            Verification.expect(new Expect(create((Class) schema), null))
                    .verify(context, actual(context.getThis()));
            return this;
        } catch (IllegalTypeException e) {
            String detailMessage = "\n" + e.getMessage();
            if (dumpInput)
                detailMessage += "\n\nThe root value was: " + input.dump();
            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) {
        expression(InputNode.INPUT_NODE, Factory.equal(), new ConstValueNode(expect))
                .evaluate(getDAL().getRuntimeContextBuilder().build(inputCode));
        return this;
    }
}

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.Data;
7	import com.github.leeonky.dal.runtime.IllegalTypeException;
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.interpreter.InterpreterException;
13	import com.github.leeonky.util.ThrowingSupplier;
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.dal("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(() -> input);	1✔
48	}
49
50	public static Assertions expectRun(ThrowingSupplier<Object> supplier) {
51	return new Assertions(supplier::get);	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	getDAL().evaluate(inputCode, fullCode, schema);	1✔
62	return this;	1✔
63	} catch (InterpreterException e) {	1✔
64	String detailMessage = e.show(fullCode, prefix.length()) + "\n\n" + e.getMessage();	1✔
65	if (dumpInput)	1✔
66	detailMessage += "\n\nThe root value was: " + getDAL().getRuntimeContextBuilder().build(inputCode).getThis().dump();	1✔
67	throw new AssertionError(detailMessage) {	1✔
68	@Override
69	public String toString() {
NEW 70	return AssertionError.class.getName() + ":\n" + getMessage();	×
71	}
72	};
73	}
74	}
75
76	private DAL getDAL() {
77	if (dal == null)	1✔
78	dal = dalFactory.get();	1✔
79	return dal;	1✔
80	}
81
82	public void exact(String verification) {
83	should("=", verification);	1✔
84	}	1✔
85
86	public void match(String verification) {
87	should(":", verification);	1✔
88	}	1✔
89
90	@SuppressWarnings("unchecked")
91	public Assertions is(Class<?> schema) {
92	RuntimeContextBuilder.DALRuntimeContext context = getDAL().getRuntimeContextBuilder().build(inputCode, schema);	1✔
93	Data<?> input = context.getThis();	1✔
94	try {
95	this.schema = schema;	1✔
96	Verification.expect(new Expect(create((Class) schema), null))	1✔
97	.verify(context, actual(context.getThis()));	1✔
98	return this;	1✔
99	} catch (IllegalTypeException e) {	1✔
100	String detailMessage = "\n" + e.getMessage();	1✔
101	if (dumpInput)	1✔
102	detailMessage += "\n\nThe root value was: " + input.dump();	1✔
103	throw new AssertionError(detailMessage);	1✔
104	}
105	}
106
107	public Assertions is(String schema) {
108	if (schema.startsWith("[") && schema.endsWith("]"))	1✔
109	return is(Array.newInstance(getDAL().getRuntimeContextBuilder().schemaType(	1✔
110	schema.replace('[', ' ').replace(']', ' ').trim()).getType(), 0).getClass());	1✔
111	return is(getDAL().getRuntimeContextBuilder().schemaType(schema).getType());	1✔
112	}
113
114	public Assertions isEqualTo(Object expect) {
115	expression(InputNode.INPUT_NODE, Factory.equal(), new ConstValueNode(expect))	×
116	.evaluate(getDAL().getRuntimeContextBuilder().build(inputCode));	×
117	return this;	×
118	}
119	}

leeonky / test-charm-java / 252

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