clojure-reader 0.6.1

#[cfg(feature = "unstable")]
mod test {
	use clojure_reader::{
		edn::{self, Edn},
		error::Code,
		parse::{self, Node, NodeKind, Position, SourceReader, Span},
	};

	#[test]
	fn node_try_into_edn_matches_read_string() {
		let input = r#"#_ :ignored {:foo [1 #_2 {:bar nil}] :baz #{true #_false :qux} :tagged #inst "1985-04-12T23:20:50.52Z"} trailing"#;

		let mut reader = SourceReader::new(input);
		let node = parse::parse(&mut reader).unwrap();
		let edn = Edn::try_from(node).unwrap();

		assert_eq!(edn, edn::read_string(input).unwrap());
		assert_eq!(reader.remaining(), " trailing");
	}

	#[test]
	fn node_try_into_edn_reports_duplicate_errors() {
		let map_node = parse::parse(&mut SourceReader::new("{:a 1 :a [2]}")).unwrap();
		let map_err = Edn::try_from(map_node).unwrap_err();
		assert_eq!(map_err.code, Code::HashMapDuplicateKey);
		assert_eq!(map_err.line, Some(1));
		assert_eq!(map_err.column, Some(13));
		assert_eq!(map_err.ptr, Some(12));

		let set_node = parse::parse(&mut SourceReader::new("#{:cat 1 2 [42] 2}")).unwrap();
		let set_err = Edn::try_from(set_node).unwrap_err();
		assert_eq!(set_err.code, Code::SetDuplicateKey);
		assert_eq!(set_err.line, Some(1));
		assert_eq!(set_err.column, Some(18));
		assert_eq!(set_err.ptr, Some(17));
	}

	#[test]
	fn node_try_into_edn_reports_invalid_tags() {
		let node = parse::parse(&mut SourceReader::new("#4 2")).unwrap();
		let err = Edn::try_from(node).unwrap_err();

		assert_eq!(err.code, Code::InvalidTag);
		assert_eq!(err.line, Some(1));
		assert_eq!(err.column, Some(2));
		assert_eq!(err.ptr, Some(1));

		for input in [
			"#foo/bar/baz nil",
			"#foo/ nil",
			"#foo//bar nil",
			"#foo/42 nil",
			"#foo/:bar nil",
			"#foo/#bar nil",
			"#foo/-42 nil",
			"#foo/+42 nil",
			"#foo/.42 nil",
			"#foo|bar nil",
			"#foo@bar nil",
			"#:foo 1",
		] {
			let node = parse::parse(&mut SourceReader::new(input)).unwrap();
			assert_eq!(Edn::try_from(node).unwrap_err().code, Code::InvalidTag);
		}
	}

	#[test]
	fn node_try_into_edn_covers_remaining_variants() {
		let node = Node::no_discards(
			NodeKind::List(
				vec![
					Node::no_discards(NodeKind::Symbol("sym"), Span::default()),
					Node::no_discards(NodeKind::Rational((3, 2)), Span::default()),
					Node::no_discards(NodeKind::Char('z'), Span::default()),
				],
				vec![],
			),
			Span::default(),
		);
		assert_eq!(
			Edn::try_from(node).unwrap(),
			Edn::List(vec![Edn::Symbol("sym"), Edn::Rational((3, 2)), Edn::Char('z')])
		);

		#[cfg(feature = "floats")]
		assert_eq!(
			Edn::try_from(Node::no_discards(NodeKind::Double((2.5).into()), Span::default())).unwrap(),
			Edn::Double((2.5).into())
		);

		#[cfg(feature = "arbitrary-nums")]
		{
			use bigdecimal::BigDecimal;
			use num_bigint::BigInt;

			assert_eq!(
				Edn::try_from(Node::no_discards(NodeKind::BigInt(BigInt::from(42)), Span::default()))
					.unwrap(),
				Edn::BigInt(BigInt::from(42))
			);
			assert_eq!(
				Edn::try_from(Node::no_discards(NodeKind::BigDec(BigDecimal::from(42)), Span::default(),))
					.unwrap(),
				Edn::BigDec(BigDecimal::from(42))
			);
		}
	}

	#[test]
	fn parse_rejects_maps_with_odd_elements() {
		let err = parse::parse(&mut SourceReader::new("{:a}")).unwrap_err();

		assert_eq!(err.code, Code::UnexpectedEOF);
		assert_eq!(err.line, Some(1));
		assert_eq!(err.column, Some(4));
		assert_eq!(err.ptr, Some(3));
	}

	#[test]
	fn source_reader_finish_keeps_source_and_position() {
		let mut reader = SourceReader::new("(cat) [42]");
		let _ = parse::parse(&mut reader).unwrap();

		let (position, source) = reader.finish();

		assert_eq!(position, Position { line: 1, column: 6, ptr: 5 });
		assert_eq!(source, "(cat) [42]");
		assert_eq!(&source[position.ptr..], " [42]");
	}
}