Lines
100 %
Functions
Branches
/*
* Hurl (https://hurl.dev)
* Copyright (C) 2026 Orange
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use crate::ast::Bytes;
use crate::combinator::choice;
use crate::reader::Reader;
use super::json::parse as parse_json;
use super::multiline::multiline_string;
use super::string::backtick_template;
use super::{ParseResult, primitives, xml};
pub fn bytes(reader: &mut Reader) -> ParseResult<Bytes> {
choice(
&[
multiline_string_bytes,
string_bytes,
json_bytes,
xml_bytes,
base64_bytes,
hex_bytes,
file_bytes,
],
reader,
)
}
fn xml_bytes(reader: &mut Reader) -> ParseResult<Bytes> {
match xml::parse(reader) {
Err(e) => Err(e),
Ok(value) => Ok(Bytes::Xml(value)),
fn json_bytes(reader: &mut Reader) -> ParseResult<Bytes> {
match parse_json(reader) {
Ok(value) => Ok(Bytes::Json(value)),
fn file_bytes(reader: &mut Reader) -> ParseResult<Bytes> {
primitives::file(reader).map(Bytes::File)
fn base64_bytes(reader: &mut Reader) -> ParseResult<Bytes> {
primitives::base64(reader).map(Bytes::Base64)
fn hex_bytes(reader: &mut Reader) -> ParseResult<Bytes> {
primitives::hex(reader).map(Bytes::Hex)
pub fn multiline_string_bytes(reader: &mut Reader) -> ParseResult<Bytes> {
multiline_string(reader).map(Bytes::MultilineString)
fn string_bytes(reader: &mut Reader) -> ParseResult<Bytes> {
backtick_template(reader).map(Bytes::OnelineString)
#[cfg(test)]
mod tests {
use crate::ast::{
JsonListElement, JsonValue, JsonValueKind, SourceInfo, Template, TemplateElement,
};
use crate::parser::ParseErrorKind;
use crate::reader::{CharPos, Pos};
use crate::types::ToSource;
use super::*;
#[test]
fn test_bytes_json() {
let mut reader = Reader::new("[1,2,3] ");
assert_eq!(
bytes(&mut reader).unwrap(),
Bytes::Json(JsonValue::new(
SourceInfo::new(Pos::new(1, 1), Pos::new(1, 8)),
JsonValueKind::List {
space0: String::new(),
elements: vec![
JsonListElement {
value: JsonValue::new(
SourceInfo::new(Pos::new(1, 2), Pos::new(1, 3)),
JsonValueKind::Number("1".to_string()),
),
space1: String::new(),
},
SourceInfo::new(Pos::new(1, 4), Pos::new(1, 5)),
JsonValueKind::Number("2".to_string()),
SourceInfo::new(Pos::new(1, 6), Pos::new(1, 7)),
JsonValueKind::Number("3".to_string()),
))
);
assert_eq!(reader.cursor().index, CharPos(7));
let mut reader = Reader::new("{ } ");
SourceInfo::new(Pos::new(1, 1), Pos::new(1, 4)),
JsonValueKind::Object {
space0: " ".to_string(),
elements: vec![],
assert_eq!(reader.cursor().index, CharPos(3));
let mut reader = Reader::new("true");
SourceInfo::new(Pos::new(1, 1), Pos::new(1, 5)),
JsonValueKind::Boolean(true),
assert_eq!(reader.cursor().index, CharPos(4));
let mut reader = Reader::new("\"\" x");
let template = Template::new(
Some('"'),
vec![],
SourceInfo::new(Pos::new(1, 2), Pos::new(1, 2)),
SourceInfo::new(Pos::new(1, 1), Pos::new(1, 3)),
JsonValueKind::String(template),
assert_eq!(reader.cursor().index, CharPos(2));
fn test_bytes_xml() {
let mut reader = Reader::new("<a/>");
Bytes::Xml(String::from("<a/>"))
fn test_bytes_json_error() {
let mut reader = Reader::new("{ x ");
let error = bytes(&mut reader).err().unwrap();
assert_eq!(error.pos, Pos { line: 1, column: 3 });
error.kind,
ParseErrorKind::Expecting {
value: "\"".to_string()
fn test_bytes_multilines_error() {
let mut reader = Reader::new("```\nxxx ");
assert_eq!(error.pos, Pos { line: 2, column: 5 });
value: "```".to_string()
fn test_bytes_eof() {
let mut reader = Reader::new("");
value: String::from("file")
assert!(error.recoverable);
fn test_json_bytes() {
let mut reader = Reader::new("100");
json_bytes(&mut reader).unwrap(),
JsonValueKind::Number("100".to_string()),
fn test_bytes_string() {
let mut reader = Reader::new("`foo` ");
Some('`'),
vec![TemplateElement::String {
value: "foo".to_string(),
source: "foo".to_source(),
}],
SourceInfo::new(Pos::new(1, 1), Pos::new(1, 6)),
assert_eq!(bytes(&mut reader).unwrap(), Bytes::OnelineString(template));
assert_eq!(reader.cursor().index.0, 5);