san-rs 0.3.1

A library for parsing standard algebraic notation (SAN)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171


use super::*;

macro_rules! assert_all {
    ($mv:expr, $src:expr, $dst:expr, $piece:expr, $promo:expr, $ann:expr, $check:expr, $capt:expr) => {
        match $mv.move_kind {
            MoveKind::Normal(src, dst) => {
                assert_eq!(src, $src);
                assert_eq!(dst, $dst);
            },
            _ => assert!(false)
        }
        assert_eq!($mv.piece, $piece);
        assert_eq!($mv.promotion, $promo);
        assert_eq!($mv.annotation, $ann);
        assert_eq!($mv.check_type, $check);
        assert_eq!($mv.is_capture, $capt);
    };
}

macro_rules! assert_move {
    ($mv:expr, $src:expr, $dst:expr, $piece:expr) => {
        assert_all!($mv, $src, $dst, $piece, None, None, None, false);
    };
}
macro_rules! assert_capture {
    ($mv:expr, $src:expr, $dst:expr, $piece:expr) => {
        assert_all!($mv, $src, $dst, $piece, None, None, None, true);
    };
}

#[test]
fn test_castle_short() {
    let m = Move::parse("O-O").unwrap();
    assert_eq!(m.move_kind, MoveKind::Castle(CastleType::Kingside));
    assert_eq!(m.piece, Piece::King);
    assert_eq!(m.promotion, None);
    assert_eq!(m.annotation, None);
    assert_eq!(m.check_type, None);
    assert_eq!(m.is_capture, false);
}
#[test]
fn test_castle_long() {
    let m = Move::parse("O-O-O").unwrap();
    assert_eq!(m.move_kind, MoveKind::Castle(CastleType::Queenside));
    assert_eq!(m.piece, Piece::King);
    assert_eq!(m.promotion, None);
    assert_eq!(m.annotation, None);
    assert_eq!(m.check_type, None);
    assert_eq!(m.is_capture, false);
}
#[test]
fn test_pawn() {
    assert_move!(Move::parse("e4").unwrap(), 
        super::POS_NONE, 
        Position::of(4, 4), 
        Piece::Pawn);
}
#[test]
fn test_pawn_long() {
    assert_move!(Move::parse("e2e4").unwrap(), 
        Position::of(4, 6), 
        Position::of(4, 4), 
        Piece::Pawn);
}
#[test]
fn test_piece() {
    assert_move!(Move::parse("Qe4").unwrap(), 
        super::POS_NONE, 
        Position::of(4, 4), 
        Piece::Queen);
}
#[test]
fn test_piece_file() {
    assert_move!(Move::parse("Qbe4").unwrap(), 
        Position::new(Some(1), None), 
        Position::of(4, 4), 
        Piece::Queen);
}
#[test]
fn test_piece_rank() {
    assert_move!(Move::parse("Q1e4").unwrap(), 
        Position::new(None, Some(7)), 
        Position::of(4, 4), 
        Piece::Queen);
}
#[test]
fn test_piece_long() {
    assert_move!(Move::parse("Qb1e4").unwrap(), 
        Position::of(1, 7), 
        Position::of(4, 4), 
        Piece::Queen);
}
#[test]
fn test_pawn_capture() {
    assert_capture!(Move::parse("exd4").unwrap(), 
        Position::new(Some(4), None), 
        Position::of(3, 4), 
        Piece::Pawn);
}
#[test]
fn test_pawn_capture_promotion() {
    assert_all!(Move::parse("exd8=Q").unwrap(), 
        Position::new(Some(4), None), 
        Position::of(3, 0), 
        Piece::Pawn, 
        Some(Piece::Queen), 
        None, 
        None, 
        true);
}
#[test]
fn test_pawn_capture_long() {
    assert_capture!(Move::parse("e3xd4").unwrap(),
        Position::of(4, 5),
        Position::of(3, 4),
        Piece::Pawn);
}
#[test]
fn test_piece_capture() {
    assert_capture!(Move::parse("Rxh3").unwrap(),
        super::POS_NONE,
        Position::of(7, 5),
        Piece::Rook);
}
#[test]
fn test_piece_capture_file() {
    assert_capture!(Move::parse("Rexh3").unwrap(),
        Position::new(Some(4), None),
        Position::of(7, 5),
        Piece::Rook);
}
#[test]
fn test_piece_capture_rank() {
    assert_capture!(Move::parse("R1xh3").unwrap(),
        Position::new(None, Some(7)),
        Position::of(7, 5),
        Piece::Rook);
}
#[test]
fn test_piece_capture_long() {
    assert_capture!(Move::parse("Re3xh3").unwrap(),
        Position::of(4, 5),
        Position::of(7, 5),
        Piece::Rook);
}
#[test]
fn test_pawn_promotion() {
    assert_all!(Move::parse("d8=Q").unwrap(), 
        super::POS_NONE, 
        Position::of(3, 0), 
        Piece::Pawn, 
        Some(Piece::Queen), 
        None, 
        None, 
        false);
}

#[test]
fn test_compile() {
    let s = (Move {
        move_kind: MoveKind::Normal(Position::new(Some(4), None), Position::of(3,0)),
        piece: Piece::Pawn,
        promotion: Some(Piece::Queen),
        annotation: Some(Annotation::Interesting),
        check_type: Some(CheckType::Check),
        is_capture: true
    }).compile();

    assert_eq!(s, "exd8=Q+?!");
}