pub fn new(input: &'a str) -> Lexer<'a> {

        let mut ci = input.bytes().enumerate();

        let current = ci.next();

        Lexer {

            input: input.as_bytes(),

            ci,

            current,

            flags_required: 0,

        }

    }

    pub fn require_flags(&mut self) {

        self.flags_required = 2;

    }

    fn current_pos(&mut self) -> usize {

        match self.current {

            None => self.input.len(),

            Some((pos, _)) => pos,

    }

    fn advance(&mut self) {

        self.current = self.ci.next();

    }

    fn advance_over_whitespace(&mut self) -> bool {

        let mut found_some = false;

        while self.current.is_some() && self.current.unwrap().1.is_ascii_whitespace() {

            found_some = true;

            self.current = self.ci.next();

        }

        found_some

    }

    fn advance_over_optional(&mut self, needle: u8) -> bool {

        match self.current {

            Some((_, c)) if c == needle => {

                self.advance();

                true

            _ => false,

    }

    fn advance_over_digits(&mut self) -> bool {

        let mut found_some = false;

        while self.current.is_some() && self.current.unwrap().1.is_ascii_digit() {

            found_some = true;

            self.current = self.ci.next();

        }

        found_some

    }

    fn advance_over_simple_number(&mut self) -> bool {

        let _ = self.advance_over_optional(b'-') || self.advance_over_optional(b'+');

        let found_digit = self.advance_over_digits();

        let _ = self.advance_over_optional(b'.');

        self.advance_over_digits() || found_digit

    }

    fn match_number(&mut self) -> Result<Token, LexError> {

        // remember the beginning

        let (start_pos, _) = self.current.unwrap();

        if !self.advance_over_simple_number() && start_pos != self.current_pos() {

            match self.current {

                None => return Err(LexError::UnexpectedEof),

                Some((_pos, c)) => return Err(LexError::UnexpectedByte(c)),

        }

        if self.advance_over_optional(b'e') || self.advance_over_optional(b'E') {

            let _ = self.advance_over_optional(b'-') || self.advance_over_optional(b'+');

            let _ = self.advance_over_digits();

        }

        let end_pos = match self.current {

            None => self.input.len(),

            Some((i, _)) => i,

        match std::str::from_utf8(&self.input[start_pos..end_pos])

            .unwrap()

            .parse::<f64>()

            Ok(n) => Ok(Number(n)),

            Err(_e) => Err(LexError::ParseFloatError),

    }

    fn next(&mut self) -> Option<Self::Item> {

        // eat whitespace

        self.advance_over_whitespace();

        match self.current {

            Some((pos, b',')) => {

                self.advance();

                Some((pos, Ok(Comma)))

            Some((pos, c)) if c.is_ascii_alphabetic() => {

                let token = Command(c);

                self.advance();

                Some((pos, Ok(token)))

            Some((pos, c)) if self.flags_required > 0 && c.is_ascii_digit() => match c {

                    self.flags_required -= 1;

                    self.advance();

                    Some((pos, Ok(Flag(false))))

                    self.flags_required -= 1;

                    self.advance();

                    Some((pos, Ok(Flag(true))))

                _ => Some((pos, Err(LexError::UnexpectedByte(c)))),

            Some((pos, c)) if c.is_ascii_digit() || c == b'-' || c == b'+' || c == b'.' => {

                Some((pos, self.match_number()))

            Some((pos, c)) => {

                self.advance();

                Some((pos, Err(LexError::UnexpectedByte(c))))

            None => None,

    }

    pub fn new(builder: &'b mut PathBuilder, path_str: &'b str) -> PathParser<'b> {

        let mut lexer = Lexer::new(path_str);

        let pt = lexer.next();

        PathParser {

            tokens: lexer,

            current_pos_and_token: pt,

            builder,

            current_x: 0.0,

            current_y: 0.0,

            cubic_reflection_x: 0.0,

            cubic_reflection_y: 0.0,

            quadratic_reflection_x: 0.0,

            quadratic_reflection_y: 0.0,

            subpath_start_x: 0.0,

            subpath_start_y: 0.0,

        }

    }

    fn match_command(&mut self) -> Result<u8, ParseError> {

        let result = match &self.current_pos_and_token {

            Some((_, Ok(Command(c)))) => Ok(*c),

            Some((pos, Ok(t))) => Err(ParseError::new(*pos, UnexpectedToken(*t))),

            Some((pos, Err(e))) => Err(ParseError::new(*pos, LexError(*e))),

        if result.is_ok() {

            self.current_pos_and_token = self.tokens.next();

        }

        result

    }

    fn match_number(&mut self) -> Result<f64, ParseError> {

        let result = match &self.current_pos_and_token {

            Some((_, Ok(Number(n)))) => Ok(*n),

            Some((pos, Ok(t))) => Err(ParseError::new(*pos, UnexpectedToken(*t))),

            Some((pos, Err(e))) => Err(ParseError::new(*pos, LexError(*e))),

            None => Err(ParseError::new(self.tokens.input.len(), UnexpectedEof)),

        if result.is_ok() {

            self.current_pos_and_token = self.tokens.next();

        }

        result

    }

    fn match_number_and_flags(&mut self) -> Result<(f64, bool, bool), ParseError> {

        let n = match &self.current_pos_and_token {

            Some((_, Ok(Number(n)))) => Ok(*n),

            None => Err(ParseError::new(self.tokens.input.len(), UnexpectedEof)),

        }?;

        self.tokens.require_flags();

        self.current_pos_and_token = self.tokens.next();

        self.eat_optional_comma();

        let f1 = self.match_flag()?;

        self.eat_optional_comma();

        let f2 = self.match_flag()?;

        Ok((n, f1, f2))

    }

    fn match_comma(&mut self) -> Result<(), ParseError> {

        let result = match &self.current_pos_and_token {

            Some((_, Ok(Comma))) => Ok(()),

            Some((pos, Ok(t))) => Err(ParseError::new(*pos, UnexpectedToken(*t))),

            Some((pos, Err(e))) => Err(ParseError::new(*pos, LexError(*e))),

            None => Err(ParseError::new(self.tokens.input.len(), UnexpectedEof)),

        if result.is_ok() {

            self.current_pos_and_token = self.tokens.next();

        }

        result

    }

    fn eat_optional_comma(&mut self) {

        let _ = self.match_comma();

    }

    fn match_comma_number(&mut self) -> Result<f64, ParseError> {

        self.eat_optional_comma();

        self.match_number()

    }

    fn match_flag(&mut self) -> Result<bool, ParseError> {

        let result = match self.current_pos_and_token {

            Some((_, Ok(Flag(f)))) => Ok(f),

            Some((pos, Ok(t))) => Err(ParseError::new(pos, UnexpectedToken(t))),

            Some((pos, Err(e))) => Err(ParseError::new(pos, LexError(e))),

            None => Err(ParseError::new(self.tokens.input.len(), UnexpectedEof)),

        if result.is_ok() {

            self.current_pos_and_token = self.tokens.next();

        }

        result

    }

    fn peek_command(&mut self) -> Option<u8> {

        match &self.current_pos_and_token {

            Some((_, Ok(Command(c)))) => Some(*c),

            _ => None,

    }

    fn peek_number(&mut self) -> Option<f64> {

        match &self.current_pos_and_token {

            Some((_, Ok(Number(n)))) => Some(*n),

            _ => None,

    }

    pub fn parse(&mut self) -> Result<(), ParseError> {

        if self.current_pos_and_token.is_none() {

            return Ok(());

        }

        self.moveto_drawto_command_groups()

    }

    fn error(&self, kind: ErrorKind) -> ParseError {

        match self.current_pos_and_token {

            Some((pos, _)) => ParseError {

                position: pos,

                kind,

            },

    }

    fn coordinate_pair(&mut self) -> Result<(f64, f64), ParseError> {

        Ok((self.match_number()?, self.match_comma_number()?))

    }

    fn set_current_point(&mut self, x: f64, y: f64) {

        self.current_x = x;

        self.current_y = y;

        self.cubic_reflection_x = self.current_x;

        self.cubic_reflection_y = self.current_y;

        self.quadratic_reflection_x = self.current_x;

        self.quadratic_reflection_y = self.current_y;

    }

    fn set_cubic_reflection_and_current_point(&mut self, x3: f64, y3: f64, x4: f64, y4: f64) {

        self.cubic_reflection_x = x3;

        self.cubic_reflection_y = y3;

        self.current_x = x4;

        self.current_y = y4;

        self.quadratic_reflection_x = self.current_x;

        self.quadratic_reflection_y = self.current_y;

    }

    fn set_quadratic_reflection_and_current_point(&mut self, a: f64, b: f64, c: f64, d: f64) {

        self.quadratic_reflection_x = a;

        self.quadratic_reflection_y = b;

        self.current_x = c;

        self.current_y = d;

        self.cubic_reflection_x = self.current_x;

        self.cubic_reflection_y = self.current_y;

    }

    fn emit_move_to(&mut self, x: f64, y: f64) {

        self.set_current_point(x, y);

        self.subpath_start_x = self.current_x;

        self.subpath_start_y = self.current_y;

        self.builder.move_to(self.current_x, self.current_y);

    }

    fn emit_line_to(&mut self, x: f64, y: f64) {

        self.set_current_point(x, y);

        self.builder.line_to(self.current_x, self.current_y);

    }

    fn emit_curve_to(&mut self, x2: f64, y2: f64, x3: f64, y3: f64, x4: f64, y4: f64) {

        self.set_cubic_reflection_and_current_point(x3, y3, x4, y4);

        self.builder.curve_to(x2, y2, x3, y3, x4, y4);

    }

    fn emit_quadratic_curve_to(&mut self, a: f64, b: f64, c: f64, d: f64) {

        // raise quadratic Bézier to cubic

        let x2 = (self.current_x + 2.0 * a) / 3.0;

        let y2 = (self.current_y + 2.0 * b) / 3.0;

        let x4 = c;

        let y4 = d;

        let x3 = (x4 + 2.0 * a) / 3.0;

        let y3 = (y4 + 2.0 * b) / 3.0;

        self.set_quadratic_reflection_and_current_point(a, b, c, d);

        self.builder.curve_to(x2, y2, x3, y3, x4, y4);

    }

    fn emit_arc(

        &mut self,

        rx: f64,

        ry: f64,

        x_axis_rotation: f64,

        large_arc: LargeArc,

        sweep: Sweep,

        x: f64,

        y: f64,

    ) {

        let (start_x, start_y) = (self.current_x, self.current_y);

        self.set_current_point(x, y);

        self.builder.arc(

            start_x,

            start_y,

            rx,

            ry,

            x_axis_rotation,

            large_arc,

            sweep,

            self.current_x,

            self.current_y,

        );

    }

    fn moveto_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

        let (mut x, mut y) = self.coordinate_pair()?;

        if !absolute {

            x += self.current_x;

            y += self.current_y;

        }

        self.emit_move_to(x, y);

        if self.match_comma().is_ok() || self.peek_number().is_some() {

            self.lineto_argument_sequence(absolute)

            Ok(())

    }

    fn moveto(&mut self) -> Result<(), ParseError> {

        match self.match_command()? {

            b'M' => self.moveto_argument_sequence(true),

            b'm' => self.moveto_argument_sequence(false),

            c => Err(self.error(ErrorKind::UnexpectedCommand(c))),

    }

    fn moveto_drawto_command_group(&mut self) -> Result<(), ParseError> {

        self.moveto()?;

        self.optional_drawto_commands().map(|_| ())

    }

    fn moveto_drawto_command_groups(&mut self) -> Result<(), ParseError> {

            self.moveto_drawto_command_group()?;

            if self.current_pos_and_token.is_none() {

                break;

            }

        Ok(())

    }

    fn optional_drawto_commands(&mut self) -> Result<bool, ParseError> {

        while self.drawto_command()? {

            // everything happens in the drawto_command() calls.

        }

        Ok(false)

    }

    fn match_if_drawto_command_with_absolute(&mut self) -> Option<(u8, bool)> {

        let cmd = self.peek_command();

        let result = match cmd {

            Some(b'M') => None,

            Some(b'm') => None,

            Some(c) => {

                let c_up = c.to_ascii_uppercase();

                if c == c_up {

                    Some((c_up, true))

                    Some((c_up, false))

            _ => None,

        if result.is_some() {

            let _ = self.match_command();

        }

        result

    }

    fn drawto_command(&mut self) -> Result<bool, ParseError> {

        match self.match_if_drawto_command_with_absolute() {

                self.emit_close_path();

                Ok(true)

            Some((b'L', abs)) => {

                self.lineto_argument_sequence(abs)?;

                Ok(true)

            Some((b'H', abs)) => {

                self.horizontal_lineto_argument_sequence(abs)?;

                Ok(true)

            Some((b'V', abs)) => {

                self.vertical_lineto_argument_sequence(abs)?;

                Ok(true)

            Some((b'C', abs)) => {

                self.curveto_argument_sequence(abs)?;

                Ok(true)

            Some((b'S', abs)) => {

                self.smooth_curveto_argument_sequence(abs)?;

                Ok(true)

            Some((b'Q', abs)) => {

                self.quadratic_curveto_argument_sequence(abs)?;

                Ok(true)

            Some((b'T', abs)) => {

                self.smooth_quadratic_curveto_argument_sequence(abs)?;

                Ok(true)

            Some((b'A', abs)) => {

                self.elliptical_arc_argument_sequence(abs)?;

                Ok(true)

            _ => Ok(false),

    }

    fn emit_close_path(&mut self) {

        let (x, y) = (self.subpath_start_x, self.subpath_start_y);

        self.set_current_point(x, y);

        self.builder.close_path();

    }

    fn should_break_arg_sequence(&mut self) -> bool {

        if self.match_comma().is_ok() {

            false

            self.peek_number().is_none()

    }

    fn lineto_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

            let (mut x, mut y) = self.coordinate_pair()?;

            if !absolute {

                x += self.current_x;

                y += self.current_y;

            }

            self.emit_line_to(x, y);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn horizontal_lineto_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

            let mut x = self.match_number()?;

            if !absolute {

                x += self.current_x;

            }

            let y = self.current_y;

            self.emit_line_to(x, y);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn vertical_lineto_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

            let mut y = self.match_number()?;

            if !absolute {

                y += self.current_y;

            }

            let x = self.current_x;

            self.emit_line_to(x, y);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn curveto_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

            let (mut x2, mut y2) = self.coordinate_pair()?;

            self.eat_optional_comma();

            let (mut x3, mut y3) = self.coordinate_pair()?;

            self.eat_optional_comma();

            let (mut x4, mut y4) = self.coordinate_pair()?;

            if !absolute {

                x2 += self.current_x;

                y2 += self.current_y;

                x3 += self.current_x;

                y3 += self.current_y;

                x4 += self.current_x;

                y4 += self.current_y;

            }

            self.emit_curve_to(x2, y2, x3, y3, x4, y4);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn smooth_curveto_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

            let (mut x3, mut y3) = self.coordinate_pair()?;

            self.eat_optional_comma();

            let (mut x4, mut y4) = self.coordinate_pair()?;

            if !absolute {

                x3 += self.current_x;

                y3 += self.current_y;

                x4 += self.current_x;

                y4 += self.current_y;

            }

            let (x2, y2) = (

                self.current_x + self.current_x - self.cubic_reflection_x,

                self.current_y + self.current_y - self.cubic_reflection_y,

            );

            self.emit_curve_to(x2, y2, x3, y3, x4, y4);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn quadratic_curveto_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

            let (mut a, mut b) = self.coordinate_pair()?;

            self.eat_optional_comma();

            let (mut c, mut d) = self.coordinate_pair()?;

            if !absolute {

                a += self.current_x;

                b += self.current_y;

                c += self.current_x;

                d += self.current_y;

            }

            self.emit_quadratic_curve_to(a, b, c, d);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn smooth_quadratic_curveto_argument_sequence(

        &mut self,

        absolute: bool,

    ) -> Result<(), ParseError> {

            let (mut c, mut d) = self.coordinate_pair()?;

            if !absolute {

                c += self.current_x;

                d += self.current_y;

            }

            let (a, b) = (

                self.current_x + self.current_x - self.quadratic_reflection_x,

                self.current_y + self.current_y - self.quadratic_reflection_y,

            );

            self.emit_quadratic_curve_to(a, b, c, d);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn elliptical_arc_argument_sequence(&mut self, absolute: bool) -> Result<(), ParseError> {

            let rx = self.match_number()?.abs();

            let ry = self.match_comma_number()?.abs();

            self.eat_optional_comma();

            let (x_axis_rotation, f1, f2) = self.match_number_and_flags()?;

            let large_arc = LargeArc(f1);

            let sweep = if f2 { Sweep::Positive } else { Sweep::Negative };

            self.eat_optional_comma();

            let (mut x, mut y) = self.coordinate_pair()?;

            if !absolute {

                x += self.current_x;

                y += self.current_y;

            }

            self.emit_arc(rx, ry, x_axis_rotation, large_arc, sweep, x, y);

            if self.should_break_arg_sequence() {

                break;

            }

        Ok(())

    }

    fn new(pos: usize, k: ErrorKind) -> ParseError {

        ParseError {

            position: pos,

            kind: k,

        }

    }

    fn find_error_pos(s: &str) -> Option<usize> {

        s.find('^')

    }

    fn make_parse_result(

        error_pos_str: &str,

        error_kind: Option<ErrorKind>,

    ) -> Result<(), ParseError> {

        if let Some(pos) = find_error_pos(error_pos_str) {

            Err(ParseError {

                position: pos,

                kind: error_kind.unwrap(),

            })

            assert!(error_kind.is_none());

            Ok(())

    }

    fn test_parser(

        path_str: &str,

        error_pos_str: &str,

        expected_commands: &[PathCommand],

        expected_error_kind: Option<ErrorKind>,

    ) {

        let expected_result = make_parse_result(error_pos_str, expected_error_kind);

        let mut builder = PathBuilder::default();

        let result = builder.parse(path_str);

        let path = builder.into_path();

        let commands = path.iter().collect::<Vec<_>>();

        assert_eq!(expected_commands, commands.as_slice());

        assert_eq!(expected_result, result);

    }

    fn moveto(x: f64, y: f64) -> PathCommand {

        PathCommand::MoveTo(x, y)

    }

    fn lineto(x: f64, y: f64) -> PathCommand {

        PathCommand::LineTo(x, y)

    }

    fn curveto(x2: f64, y2: f64, x3: f64, y3: f64, x4: f64, y4: f64) -> PathCommand {

        PathCommand::CurveTo(CubicBezierCurve {

            pt1: (x2, y2),

            pt2: (x3, y3),

            to: (x4, y4),

        })

    }

    fn arc(x2: f64, y2: f64, xr: f64, large_arc: bool, sweep: bool,

           x3: f64, y3: f64, x4: f64, y4: f64) -> PathCommand {

        PathCommand::Arc(EllipticalArc {

            r: (x2, y2),

            x_axis_rotation: xr,

            large_arc: LargeArc(large_arc),

            sweep: match sweep {

                true => Sweep::Positive,

                false => Sweep::Negative,

            from: (x3, y3),

            to: (x4, y4),

        })

    }

    fn closepath() -> PathCommand {

        PathCommand::ClosePath

    }

    fn handles_empty_data() {

        test_parser(

            "",

            "",

            &Vec::<PathCommand>::new(),

            None,

        );

    }

    fn handles_numbers() {

        test_parser(

            "M 10 20",

            "",

            &[moveto(10.0, 20.0)],

            None,

        );

        test_parser(

            "M -10 -20",

            "",

            &[moveto(-10.0, -20.0)],

            None,

        );

        test_parser(

            "M .10 0.20",

            "",

            &[moveto(0.10, 0.20)],

            None,

        );

        test_parser(

            "M -.10 -0.20",

            "",

            &[moveto(-0.10, -0.20)],

            None,

        );

        test_parser(

            "M-.10-0.20",

            "",

            &[moveto(-0.10, -0.20)],

            None,

        );

        test_parser(

            "M10.5.50",

            "",

            &[moveto(10.5, 0.50)],

            None,

        );

        test_parser(

            "M.10.20",

            "",

            &[moveto(0.10, 0.20)],

            None,

        );

        test_parser(

            "M .10E1 .20e-4",

            "",

            &[moveto(1.0, 0.000020)],

            None,

        );

        test_parser(

            "M-.10E1-.20",

            "",

            &[moveto(-1.0, -0.20)],

            None,

        );

        test_parser(

            "M10.10E2 -0.20e3",

            "",

            &[moveto(1010.0, -200.0)],

            None,

        );

        test_parser(

            "M-10.10E2-0.20e-3",

            "",

            &[moveto(-1010.0, -0.00020)],

            None,

        );

        test_parser(

            "M1e2.5", // a decimal after exponent start the next number

            "",

            &[moveto(100.0, 0.5)],

            None,

        );

        test_parser(

            "M1e-2.5", // but we are allowed a sign after exponent

            "",

            &[moveto(0.01, 0.5)],

            None,

        );

        test_parser(

            "M1e+2.5", // but we are allowed a sign after exponent

            "",

            &[moveto(100.0, 0.5)],

            None,

        );

    }

    fn detects_bogus_numbers() {

        test_parser(

            "M+",

            " ^",

            &[],

            Some(ErrorKind::LexError(LexError::UnexpectedEof)),

        );

        test_parser(

            "M-",

            " ^",

            &[],

            Some(ErrorKind::LexError(LexError::UnexpectedEof)),

        );

        test_parser(

            "M+x",

            " ^",

            &[],

            Some(ErrorKind::LexError(LexError::UnexpectedByte(b'x'))),

        );

        test_parser(

            "M10e",

            " ^",

            &[],

            Some(ErrorKind::LexError(LexError::ParseFloatError)),

        );

        test_parser(

            "M10ex",

            " ^",

            &[],

            Some(ErrorKind::LexError(LexError::ParseFloatError)),

        );

        test_parser(

            "M10e-",

            " ^",

            &[],

            Some(ErrorKind::LexError(LexError::ParseFloatError)),

        );

        test_parser(

            "M10e+x",

            " ^",

            &[],

            Some(ErrorKind::LexError(LexError::ParseFloatError)),

        );

    }

    fn handles_numbers_with_comma() {

        test_parser(

            "M 10, 20",

            "",

            &[moveto(10.0, 20.0)],

            None,

        );

        test_parser(

            "M -10,-20",

            "",

            &[moveto(-10.0, -20.0)],

            None,

        );

        test_parser(

            "M.10    ,    0.20",

            "",

            &[moveto(0.10, 0.20)],

            None,

        );

        test_parser(

            "M -.10, -0.20   ",

            "",

            &[moveto(-0.10, -0.20)],

            None,

        );

        test_parser(

            "M-.10-0.20",

            "",

            &[moveto(-0.10, -0.20)],

            None,

        );

        test_parser(

            "M.10.20",

            "",

            &[moveto(0.10, 0.20)],

            None,

        );

        test_parser(

            "M .10E1,.20e-4",

            "",

            &[moveto(1.0, 0.000020)],

            None,

        );

        test_parser(

            "M-.10E-2,-.20",

            "",

            &[moveto(-0.0010, -0.20)],

            None,

        );

        test_parser(

            "M10.10E2,-0.20e3",

            "",

            &[moveto(1010.0, -200.0)],

            None,

        );

        test_parser(

            "M-10.10E2,-0.20e-3",

            "",

            &[moveto(-1010.0, -0.00020)],

            None,

        );

    }

    fn handles_single_moveto() {

        test_parser(

            "M 10 20 ",

            "",

            &[moveto(10.0, 20.0)],

            None,

        );

        test_parser(

            "M10,20  ",

            "",

            &[moveto(10.0, 20.0)],

            None,

        );

        test_parser(

            "M10 20   ",

            "",

            &[moveto(10.0, 20.0)],

            None,

        );

        test_parser(

            "    M10,20     ",

            "",

            &[moveto(10.0, 20.0)],

            None,

        );

    }

    fn handles_relative_moveto() {

        test_parser(

            "m10 20",

            "",

            &[moveto(10.0, 20.0)],

            None,

        );

    }

    fn handles_absolute_moveto_with_implicit_lineto() {

        test_parser(

            "M10 20 30 40",

            "",

            &[moveto(10.0, 20.0), lineto(30.0, 40.0)],

            None,

        );

        test_parser(

            "M10,20,30,40",

            "",

            &[moveto(10.0, 20.0), lineto(30.0, 40.0)],

            None,

        );

        test_parser(

            "M.1-2,3E2-4",

            "",

            &[moveto(0.1, -2.0), lineto(300.0, -4.0)],

            None,

        );

    }

    fn handles_relative_moveto_with_implicit_lineto() {

        test_parser(

            "m10 20 30 40",

            "",

            &[moveto(10.0, 20.0), lineto(40.0, 60.0)],

            None,

        );

    }

    fn handles_relative_moveto_with_relative_lineto_sequence() {

        test_parser(

            //          1     2    3    4   5

            "m 46,447 l 0,0.5 -1,0 -1,0 0,1 0,12",

            "",

            &vec![moveto(46.0, 447.0), lineto(46.0, 447.5), lineto(45.0, 447.5),

                  lineto(44.0, 447.5), lineto(44.0, 448.5), lineto(44.0, 460.5)],

            None,

        );

    }

    fn handles_absolute_moveto_with_implicit_linetos() {

        test_parser(

            "M10,20 30,40,50 60",

            "",

            &[moveto(10.0, 20.0), lineto(30.0, 40.0), lineto(50.0, 60.0)],

            None,

        );

    }

    fn handles_relative_moveto_with_implicit_linetos() {

        test_parser(

            "m10 20 30 40 50 60",

            "",

            &[moveto(10.0, 20.0), lineto(40.0, 60.0), lineto(90.0, 120.0)],

            None,

        );

    }

    fn handles_absolute_moveto_moveto() {

        test_parser(

            "M10 20 M 30 40",

            "",

            &[moveto(10.0, 20.0), moveto(30.0, 40.0)],

            None,

        );

    }

    fn handles_relative_moveto_moveto() {

        test_parser(

            "m10 20 m 30 40",

            "",

            &[moveto(10.0, 20.0), moveto(40.0, 60.0)],

            None,

        );

    }

    fn handles_relative_moveto_lineto_moveto() {

        test_parser(

            "m10 20 30 40 m 50 60",

            "",

            &[moveto(10.0, 20.0), lineto(40.0, 60.0), moveto(90.0, 120.0)],

            None,

        );

    }

    fn handles_absolute_moveto_lineto() {

        test_parser(

            "M10 20 L30,40",

            "",

            &[moveto(10.0, 20.0), lineto(30.0, 40.0)],

            None,

        );

    }

    fn handles_relative_moveto_lineto() {

        test_parser(

            "m10 20 l30,40",

            "",

            &[moveto(10.0, 20.0), lineto(40.0, 60.0)],