fml 0.5.0

// Function names correspond to enum value names.
#![allow(non_snake_case)]

use super::*;

#[test]
fn Linebreak() {
	assert!(
		Token::Linebreak
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Linebreak)
	);
}

#[test]
fn CodeInline() {
	let s = "Meow >:3c".to_string();

	assert!(
		Token::CodeInline(s.clone())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::CodeInline(s))
	)
}

mod CodeBlock {
	use super::*;

	fn body() -> Vec<FmlCodeBlockValue> {
		vec![
			FmlCodeBlockValue::Str("line of code".into()),
			FmlCodeBlockValue::Linebreak,
		]
	}

	#[test]
	fn none() {
		assert!(
			Token::CodeBlock {
				lang: None,
				body: body()
			}
			.try_into()
			.is_ok_and(|v: FmlValue| v
				== FmlValue::CodeBlock {
					lang: None,
					body: body()
				})
		)
	}
	#[test]
	fn some() {
		let lang = Some("rust".into());

		assert!(
			Token::CodeBlock {
				lang: lang.clone(),
				body: body()
			}
			.try_into()
			.is_ok_and(|v: FmlValue| v
				== FmlValue::CodeBlock {
					lang: lang,
					body: body()
				})
		)
	}
}

#[test]
fn Hyperlink() {
	let uri = "~".to_string();
	assert!(
		Token::Hyperlink {
			fml: Default::default(),
			uri: uri.clone()
		}
		.try_into()
		.is_ok_and(|v: FmlValue| v
			== FmlValue::Hyperlink {
				fml: Default::default(),
				uri
			})
	)
}

#[test]
fn Heading1() {
	assert!(
		Token::Heading1(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Heading1(Default::default()))
	)
}

#[test]
fn Heading2() {
	assert!(
		Token::Heading2(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Heading2(Default::default()))
	)
}

#[test]
fn Heading3() {
	assert!(
		Token::Heading3(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Heading3(Default::default()))
	)
}

#[test]
fn Superline() {
	assert!(
		Token::SupLine(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Superline(Default::default()))
	)
}

#[test]
fn Subline() {
	assert!(
		Token::SubLine(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Subline(Default::default()))
	)
}

#[test]
fn Bold() {
	assert!(
		Token::Bold(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Bold(Default::default()))
	)
}

#[test]
fn Italic() {
	assert!(
		Token::Italic(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Italic(Default::default()))
	)
}

#[test]
fn Strikethrough() {
	assert!(
		Token::Strikethrough(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Strikethrough(Default::default()))
	)
}

#[test]
fn Quote() {
	assert!(
		// Giving the Quote some content because, just like any other token,
		// an empty version cannot exist.
		// Default (empty) values work fine in other tests because other tokens
		// don't require postprocessing like quotes do.
		Token::Quote("a".to_string()).try_into().is_ok_and(
			|v: FmlValue| v == FmlValue::Quote(vec![FmlValue::Text("a".to_string())].into())
		)
	)
}

#[test]
fn ListItem() {
	assert!(
		Token::ListItem(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::ListItem(Default::default()))
	)
}

#[test]
fn Function() {
	assert!(
		Token::Function(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Function(Default::default()))
	)
}

#[test]
fn Superscript() {
	assert!(
		Token::Superscript(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Superscript(Default::default()))
	)
}

#[test]
fn Subscript() {
	assert!(
		Token::Subscript(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Subscript(Default::default()))
	)
}

#[test]
fn Underline() {
	assert!(
		Token::Underline(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Underline(Default::default()))
	)
}

#[test]
fn Typst() {
	assert!(
		Token::Typst(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Typst(Default::default()))
	)
}

#[test]
fn Text() {
	assert!(
		Token::Text(Default::default())
			.try_into()
			.is_ok_and(|v: FmlValue| v == FmlValue::Text(Default::default()))
	)
}