#[cfg(test)]
mod tests {
use crate::test_helpers::*;
#[test]
fn test_bif_defined() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; __test-nts >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_undefined() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; undefined-var >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_undefined_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; undefined-var >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not defined</div>");
}
#[test]
fn test_bif_defined_obj_levels() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; __test-obj-nts->level1-obj->level2-obj->level2 >> {:;__test-obj-nts->level1-obj->level2-obj->level2:} :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>Ok</div>");
}
#[test]
fn test_bif_defined_evaluate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; __test-{:;__test-nts:} >> {:;__test-nts:} :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>nts</div>");
}
#[test]
fn test_bif_defined_scope() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:+defined; __test-nts >> {:include; tests/snippets.ntpl :} :}{:snippet; test-snippet :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div><div>test snippet</div></div>");
}
#[test]
fn test_bif_defined_no_scope() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; __test-nts >> {:include; tests/snippets.ntpl :} :}{:snippet; test-snippet :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_true() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; true >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_false() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; false >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_text() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; text >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_zero() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; zero >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_one() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; one >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_spaces() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; spaces >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_empty() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; empty >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_null() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; null >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_emptyarr() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; emptyarr >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_array() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_true_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::true >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_false_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::false >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_text_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::text >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_zero_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::zero >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_one_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::one >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_spaces_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::spaces >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_empty_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::empty >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_null_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::null >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_emptyarr_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::emptyarr >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_array_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:data; tests/local-data.json :}{:defined; local::array >> is defined :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_true_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; true >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_false_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; false >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_text_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; text >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_zero_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; zero >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_one_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; one >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_spaces_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; spaces >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_empty_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; empty >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_null_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; null >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not defined</div>");
}
#[test]
fn test_bif_defined_emptyarr_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; emptyarr >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_array_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_true_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::true >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_false_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::false >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_text_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::text >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_zero_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::zero >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_one_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::one >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_spaces_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::spaces >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_empty_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::empty >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_null_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::null >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not defined</div>");
}
#[test]
fn test_bif_defined_emptyarr_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::emptyarr >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_array_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_true() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->true >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_false() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->false >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_text() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->text >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_zero() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->zero >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_one() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->one >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_spaces() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->spaces >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_empty() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->empty >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_null() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:defined; array->null >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_true_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->true >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_false_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->false >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_text_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->text >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_zero_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->zero >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_one_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->one >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_spaces_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->spaces >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_empty_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->empty >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is defined</div>");
}
#[test]
fn test_bif_defined_arr_null_local() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:defined; local::array->null >> is defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_true_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->true >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_false_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->false >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_text_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->text >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_zero_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->zero >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_one_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->one >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_spaces_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->spaces >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_empty_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->empty >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_null_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:!defined; array->null >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not defined</div>");
}
#[test]
fn test_bif_defined_arr_true_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->true >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_false_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->false >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_text_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->text >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_zero_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->zero >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_one_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->one >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_spaces_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->spaces >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_empty_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->empty >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_defined_arr_null_local_negate() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str("<div>{:data; tests/local-data.json :}{:!defined; local::array->null >> is not defined :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not defined</div>");
}
#[test]
fn test_bif_defined_invalid_flag() {
let mut template = match crate::Template::new() {
Ok(tpl) => tpl,
Err(error) => {
println!("Error creating Template: {}", error);
assert!(false);
return;
}
};
template.merge_schema_str(SCHEMA).unwrap();
template.set_src_str(
"<div>{:defined; {:flg; invalid_flag :} __test-nts >> is defined :}</div>",
);
let result = template.render();
assert!(template.has_error());
assert_eq!(result, "<div></div>");
}
}