#[cfg(test)]
mod tests {
use crate::test_helpers::*;
#[test]
fn test_bif_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>{:array; __test-obj-nts >> nts :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>nts</div>");
}
#[test]
fn test_bif_array_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>{:array; __test-obj-nts->level1-obj->level2-obj >> Ok :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>Ok</div>");
}
#[test]
fn test_bif_array_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>{:array; __test-obj-{:;__test-nts:} >> {:;__test-nts:} :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>nts</div>");
}
#[test]
fn test_bif_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>{:!array; __test-obj-nts >> nts :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_negate_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>{:!array; undefined-var >> nts :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>nts</div>");
}
#[test]
fn test_bif_array_obj_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>{:array; __test-obj-empty-nts >> nts :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>nts</div>");
}
#[test]
fn test_bif_array_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>{:+array; __test-obj-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_array_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>{:array; __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_array_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>{:array; true >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; false >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; text >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; zero >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; one >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; spaces >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; empty >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; null >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; emptyarr >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is array</div>");
}
#[test]
fn test_bif_array_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>{:array; array >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is array</div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::true >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::false >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::text >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::zero >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::one >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::spaces >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::empty >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::null >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is array</div>");
}
#[test]
fn test_bif_array_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>{:!array; true >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; false >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; text >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; zero >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; one >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; spaces >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; empty >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; null >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; emptyarr >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:!array; array >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::true >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::false >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::text >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::zero >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::one >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::spaces >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::empty >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::null >> is not array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:array; array->true >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; array->false >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; array->text >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; array->zero >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; array->one >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; array->spaces >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; array->empty >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:array; array->null >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_arr_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>{:array; array->empty >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->true >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->false >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->text >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->zero >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->one >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->spaces >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->empty >> is array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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 :}{:array; local::array->null >> is array :}</div>",
);
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div></div>");
}
#[test]
fn test_bif_array_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>{:!array; array->true >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; array->false >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; array->text >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; array->zero >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; array->one >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; array->spaces >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; array->empty >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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>{:!array; array->null >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_arr_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>{:!array; array->empty >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->true >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->false >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->text >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->zero >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->one >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->spaces >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->empty >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_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 :}{:!array; local::array->null >> is not array :}</div>");
let result = template.render();
assert!(!template.has_error());
assert_eq!(result, "<div>is not array</div>");
}
#[test]
fn test_bif_array_flags_not_allowed() {
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>{:array; {:flg; invalid_flag :} array >> nts :}</div>");
let result = template.render();
assert!(template.has_error());
assert_eq!(result, "<div></div>");
}
}