4007820649

Build # 4007820649

Build Type

github

Committed by GitHub

Commit Message

Merge b71e66da1 into 6c0ac2b2c

Pull Request Pull Request #734: Bump ahash from 0.8.2 to 0.8.3

Run Details

23507 of 35166 relevant lines covered (66.85%)

40241.5 hits per line

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

91.25

/dozer-sql/src/pipeline/expression/scalar/tests/number.rs

use crate::pipeline::expression::execution::Expression::Literal;
use crate::pipeline::expression::scalar::number::evaluate_round;
use crate::pipeline::expression::scalar::tests::scalar_common::run_scalar_fct;
use dozer_types::ordered_float::OrderedFloat;
use dozer_types::types::{Field, FieldDefinition, FieldType, Record, Schema, SourceDefinition};

#[test]
fn test_abs() {
    let f = run_scalar_fct(
        "SELECT ABS(c) FROM USERS",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("c"),
                    FieldType::Int,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Int(-1)],
    );
    assert_eq!(f, Field::Int(1));
}

#[test]
fn test_round() {
    let row = Record::new(None, vec![], None);

    let v = Box::new(Literal(Field::Int(1)));
    let d = &Box::new(Literal(Field::Int(0)));
    assert_eq!(
        evaluate_round(&Schema::empty(), &v, Some(d), &row)
            .unwrap_or_else(|e| panic!("{}", e.to_string())),
        Field::Int(1)
    );

    let v = Box::new(Literal(Field::Float(OrderedFloat(2.1))));
    let d = &Box::new(Literal(Field::Int(0)));
    assert_eq!(
        evaluate_round(&Schema::empty(), &v, Some(d), &row)
            .unwrap_or_else(|e| panic!("{}", e.to_string())),
        Field::Float(OrderedFloat(2.0))
    );

    let v = Box::new(Literal(Field::Float(OrderedFloat(2.6))));
    let d = &Box::new(Literal(Field::Int(0)));
    assert_eq!(
        evaluate_round(&Schema::empty(), &v, Some(d), &row)
            .unwrap_or_else(|e| panic!("{}", e.to_string())),
        Field::Float(OrderedFloat(3.0))
    );

    let v = Box::new(Literal(Field::Float(OrderedFloat(2.633))));
    let d = &Box::new(Literal(Field::Int(2)));
    assert_eq!(
        evaluate_round(&Schema::empty(), &v, Some(d), &row)
            .unwrap_or_else(|e| panic!("{}", e.to_string())),
        Field::Float(OrderedFloat(2.63))
    );

    let v = Box::new(Literal(Field::Float(OrderedFloat(212.633))));
    let d = &Box::new(Literal(Field::Int(-2)));
    assert_eq!(
        evaluate_round(&Schema::empty(), &v, Some(d), &row)
            .unwrap_or_else(|e| panic!("{}", e.to_string())),
        Field::Float(OrderedFloat(200.0))
    );

    let v = Box::new(Literal(Field::Float(OrderedFloat(2.633))));
    let d = &Box::new(Literal(Field::Float(OrderedFloat(2.1))));
    assert_eq!(
        evaluate_round(&Schema::empty(), &v, Some(d), &row)
            .unwrap_or_else(|e| panic!("{}", e.to_string())),
        Field::Float(OrderedFloat(2.63))
    );

    let v = Box::new(Literal(Field::Float(OrderedFloat(2.633))));
    let d = &Box::new(Literal(Field::String("2.3".to_string())));
    assert_eq!(
        evaluate_round(&Schema::empty(), &v, Some(d), &row)
            .unwrap_or_else(|e| panic!("{}", e.to_string())),
        Field::Float(OrderedFloat(3.0))
    );
}

1	use crate::pipeline::expression::execution::Expression::Literal;
2	use crate::pipeline::expression::scalar::number::evaluate_round;
3	use crate::pipeline::expression::scalar::tests::scalar_common::run_scalar_fct;
4	use dozer_types::ordered_float::OrderedFloat;
5	use dozer_types::types::{Field, FieldDefinition, FieldType, Record, Schema, SourceDefinition};
6
7	#[test]	1✔
8	fn test_abs() {	1✔
9	let f = run_scalar_fct(	1✔
10	"SELECT ABS(c) FROM USERS",	1✔
11	Schema::empty()	1✔
12	.field(	1✔
13	FieldDefinition::new(	1✔
14	String::from("c"),	1✔
15	FieldType::Int,	1✔
16	false,	1✔
17	SourceDefinition::Dynamic,	1✔
18	),	1✔
19	false,	1✔
20	)	1✔
21	.clone(),	1✔
22	vec![Field::Int(-1)],	1✔
23	);	1✔
24	assert_eq!(f, Field::Int(1));	1✔
25	}	1✔
26		×
27	#[test]	1✔
28	fn test_round() {	1✔
29	let row = Record::new(None, vec![], None);	1✔
30		1✔
31	let v = Box::new(Literal(Field::Int(1)));	1✔
32	let d = &Box::new(Literal(Field::Int(0)));	1✔
33	assert_eq!(	1✔
34	evaluate_round(&Schema::empty(), &v, Some(d), &row)	1✔
35	.unwrap_or_else(\|e\| panic!("{}", e.to_string())),	1✔
36	Field::Int(1)	1✔
37	);	1✔
38		×
39	let v = Box::new(Literal(Field::Float(OrderedFloat(2.1))));	1✔
40	let d = &Box::new(Literal(Field::Int(0)));	1✔
41	assert_eq!(	1✔
42	evaluate_round(&Schema::empty(), &v, Some(d), &row)	1✔
43	.unwrap_or_else(\|e\| panic!("{}", e.to_string())),	1✔
44	Field::Float(OrderedFloat(2.0))	1✔
45	);	1✔
46		×
47	let v = Box::new(Literal(Field::Float(OrderedFloat(2.6))));	1✔
48	let d = &Box::new(Literal(Field::Int(0)));	1✔
49	assert_eq!(	1✔
50	evaluate_round(&Schema::empty(), &v, Some(d), &row)	1✔
51	.unwrap_or_else(\|e\| panic!("{}", e.to_string())),	1✔
52	Field::Float(OrderedFloat(3.0))	1✔
53	);	1✔
54		×
55	let v = Box::new(Literal(Field::Float(OrderedFloat(2.633))));	1✔
56	let d = &Box::new(Literal(Field::Int(2)));	1✔
57	assert_eq!(	1✔
58	evaluate_round(&Schema::empty(), &v, Some(d), &row)	1✔
59	.unwrap_or_else(\|e\| panic!("{}", e.to_string())),	1✔
60	Field::Float(OrderedFloat(2.63))	1✔
61	);	1✔
62		×
63	let v = Box::new(Literal(Field::Float(OrderedFloat(212.633))));	1✔
64	let d = &Box::new(Literal(Field::Int(-2)));	1✔
65	assert_eq!(	1✔
66	evaluate_round(&Schema::empty(), &v, Some(d), &row)	1✔
67	.unwrap_or_else(\|e\| panic!("{}", e.to_string())),	1✔
68	Field::Float(OrderedFloat(200.0))	1✔
69	);	1✔
70		×
71	let v = Box::new(Literal(Field::Float(OrderedFloat(2.633))));	1✔
72	let d = &Box::new(Literal(Field::Float(OrderedFloat(2.1))));	1✔
73	assert_eq!(	1✔
74	evaluate_round(&Schema::empty(), &v, Some(d), &row)	1✔
75	.unwrap_or_else(\|e\| panic!("{}", e.to_string())),	1✔
76	Field::Float(OrderedFloat(2.63))	1✔
77	);	1✔
78		×
79	let v = Box::new(Literal(Field::Float(OrderedFloat(2.633))));	1✔
80	let d = &Box::new(Literal(Field::String("2.3".to_string())));	1✔
81	assert_eq!(	1✔
82	evaluate_round(&Schema::empty(), &v, Some(d), &row)	1✔
83	.unwrap_or_else(\|e\| panic!("{}", e.to_string())),	1✔
84	Field::Float(OrderedFloat(3.0))	1✔
85	);	1✔
86	}	1✔

getdozer / dozer / 4007820649

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