172 lines
4.7 KiB
Rust
172 lines
4.7 KiB
Rust
#![feature(plugin)]
|
|
#![plugin(maud_macros)]
|
|
|
|
extern crate maud;
|
|
|
|
use maud::Markup;
|
|
|
|
#[test]
|
|
fn literals() {
|
|
let s = html!("du\tcks" "-23" "3.14\n" "geese").into_string();
|
|
assert_eq!(s, "du\tcks-233.14\ngeese");
|
|
}
|
|
|
|
#[test]
|
|
fn escaping() {
|
|
let s = html!("<flim&flam>").into_string();
|
|
assert_eq!(s, "<flim&flam>");
|
|
}
|
|
|
|
#[test]
|
|
fn semicolons() {
|
|
let s = html! {
|
|
"one";
|
|
"two";
|
|
"three";
|
|
;;;;;;;;;;;;;;;;;;;;;;;;
|
|
"four";
|
|
}.into_string();
|
|
assert_eq!(s, "onetwothreefour");
|
|
}
|
|
|
|
#[test]
|
|
fn blocks() {
|
|
let s = html! {
|
|
"hello"
|
|
{
|
|
" ducks" " geese"
|
|
}
|
|
" swans"
|
|
}.into_string();
|
|
assert_eq!(s, "hello ducks geese swans");
|
|
}
|
|
|
|
#[test]
|
|
fn simple_elements() {
|
|
let s = html!(p { b { "pickle" } "barrel" i { "kumquat" } }).into_string();
|
|
assert_eq!(s, "<p><b>pickle</b>barrel<i>kumquat</i></p>");
|
|
}
|
|
|
|
#[test]
|
|
fn nesting_elements() {
|
|
let s = html!(html body div p sup "butts").into_string();
|
|
assert_eq!(s, "<html><body><div><p><sup>butts</sup></p></div></body></html>");
|
|
}
|
|
|
|
#[test]
|
|
fn empty_elements() {
|
|
let s = html!("pinkie" br/ "pie").into_string();
|
|
assert_eq!(s, "pinkie<br>pie");
|
|
}
|
|
|
|
#[test]
|
|
fn simple_attributes() {
|
|
let s = html! {
|
|
link rel="stylesheet" href="styles.css"/
|
|
section id="midriff" {
|
|
p class="hotpink" "Hello!"
|
|
}
|
|
}.into_string();
|
|
assert_eq!(s, concat!(
|
|
r#"<link rel="stylesheet" href="styles.css">"#,
|
|
r#"<section id="midriff"><p class="hotpink">Hello!</p></section>"#));
|
|
}
|
|
|
|
#[test]
|
|
fn empty_attributes() {
|
|
let s = html!(div readonly? input type="checkbox" checked? /).into_string();
|
|
assert_eq!(s, r#"<div readonly><input type="checkbox" checked></div>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn toggle_empty_attributes() {
|
|
let rocks = true;
|
|
let s = html!({
|
|
input checked?[true] /
|
|
input checked?[false] /
|
|
input checked?[rocks] /
|
|
input checked?[!rocks] /
|
|
}).into_string();
|
|
assert_eq!(s, concat!(
|
|
r#"<input checked>"#,
|
|
r#"<input>"#,
|
|
r#"<input checked>"#,
|
|
r#"<input>"#));
|
|
}
|
|
|
|
#[test]
|
|
fn colons_in_names() {
|
|
let s = html!(pon-pon:controls-alpha a on:click="yay()" "Yay!").into_string();
|
|
assert_eq!(s, concat!(
|
|
r#"<pon-pon:controls-alpha>"#,
|
|
r#"<a on:click="yay()">Yay!</a>"#,
|
|
r#"</pon-pon:controls-alpha>"#));
|
|
}
|
|
|
|
#[test]
|
|
fn hyphens_in_element_names() {
|
|
let s = html!(custom-element {}).into_string();
|
|
assert_eq!(s, "<custom-element></custom-element>");
|
|
}
|
|
|
|
#[test]
|
|
fn hyphens_in_attribute_names() {
|
|
let s = html!(this sentence-is="false" of-course? {}).into_string();
|
|
assert_eq!(s, r#"<this sentence-is="false" of-course></this>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn class_shorthand() {
|
|
let s = html!(p { "Hi, " span.name { "Lyra" } "!" }).into_string();
|
|
assert_eq!(s, r#"<p>Hi, <span class="name">Lyra</span>!</p>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn class_shorthand_with_space() {
|
|
let s = html!(p { "Hi, " span .name { "Lyra" } "!" }).into_string();
|
|
assert_eq!(s, r#"<p>Hi, <span class="name">Lyra</span>!</p>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn classes_shorthand() {
|
|
let s = html!(p { "Hi, " span.name.here { "Lyra" } "!" }).into_string();
|
|
assert_eq!(s, r#"<p>Hi, <span class="name here">Lyra</span>!</p>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn hyphens_in_class_names() {
|
|
let s = html!(p.rocks-these.are--my--rocks "yes").into_string();
|
|
assert_eq!(s, r#"<p class="rocks-these are--my--rocks">yes</p>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn toggle_classes() {
|
|
fn test(is_cupcake: bool, is_muffin: bool) -> Markup {
|
|
html!(p.cupcake[is_cupcake].muffin[is_muffin] "Testing!")
|
|
}
|
|
assert_eq!(test(true, true).into_string(), r#"<p class="cupcake muffin">Testing!</p>"#);
|
|
assert_eq!(test(false, true).into_string(), r#"<p class=" muffin">Testing!</p>"#);
|
|
assert_eq!(test(true, false).into_string(), r#"<p class="cupcake">Testing!</p>"#);
|
|
assert_eq!(test(false, false).into_string(), r#"<p class="">Testing!</p>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn mixed_classes() {
|
|
fn test(is_muffin: bool) -> Markup {
|
|
html!(p.cupcake.muffin[is_muffin].lamington "Testing!")
|
|
}
|
|
assert_eq!(test(true).into_string(), r#"<p class="cupcake lamington muffin">Testing!</p>"#);
|
|
assert_eq!(test(false).into_string(), r#"<p class="cupcake lamington">Testing!</p>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn ids_shorthand() {
|
|
let s = html!(p { "Hi, " span#thing { "Lyra" } "!" }).into_string();
|
|
assert_eq!(s, r#"<p>Hi, <span id="thing">Lyra</span>!</p>"#);
|
|
}
|
|
|
|
#[test]
|
|
fn classes_attrs_ids_mixed_up() {
|
|
let s = html!(p { "Hi, " span.name.here lang="en" #thing { "Lyra" } "!" }).into_string();
|
|
assert_eq!(s, "<p>Hi, <span lang=\"en\" class=\"name here\" id=\"thing\">Lyra</span>!</p>");
|
|
}
|