opensmiles 0.1.3

A SMILES parser following the OpenSMILES specification
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

//! Explicit bond tests
//!
//! These tests verify the parsing of different bond types:
//! - Simple (`-`)
//! - Double (`=`)
//! - Triple (`#`)
//! - Quadruple (`$`)
//! - Aromatic (`:`)

use opensmiles::{parse, BondType};

#[test]
fn parse_explicit_single_bond() {
    // C-C = ethane with explicit single bond
    let molecule = parse("C-C").expect("Failed to parse C-C");

    assert_eq!(molecule.nodes().len(), 2);
    assert_eq!(molecule.bonds().len(), 1);

    let bond = &molecule.bonds()[0];
    assert_eq!(bond.kind(), BondType::Simple);
    assert_eq!(bond.source(), 0);
    assert_eq!(bond.target(), 1);

    // Check implicit hydrogens (CH3-CH3)
    assert_eq!(molecule.nodes()[0].hydrogens(), 3);
    assert_eq!(molecule.nodes()[1].hydrogens(), 3);
}

#[test]
fn parse_double_bond() {
    // C=C = ethene (ethylene): double bond
    let molecule = parse("C=C").expect("Failed to parse ethene");

    assert_eq!(molecule.nodes().len(), 2);
    assert_eq!(molecule.bonds().len(), 1);

    let bond = &molecule.bonds()[0];
    assert_eq!(bond.kind(), BondType::Double);
    assert_eq!(bond.source(), 0);
    assert_eq!(bond.target(), 1);

    // CH2=CH2: each carbon has 2 hydrogens
    assert_eq!(molecule.nodes()[0].hydrogens(), 2);
    assert_eq!(molecule.nodes()[1].hydrogens(), 2);
}

#[test]
fn parse_triple_bond() {
    // C#C = ethyne (acetylene): triple bond
    let molecule = parse("C#C").expect("Failed to parse ethyne");

    assert_eq!(molecule.nodes().len(), 2);
    assert_eq!(molecule.bonds().len(), 1);

    let bond = &molecule.bonds()[0];
    assert_eq!(bond.kind(), BondType::Triple);
    assert_eq!(bond.source(), 0);
    assert_eq!(bond.target(), 1);

    // HC≡CH: each carbon has 1 hydrogen
    assert_eq!(molecule.nodes()[0].hydrogens(), 1);
    assert_eq!(molecule.nodes()[1].hydrogens(), 1);
}

#[test]
fn parse_quadruple_bond() {
    // C$C = quadruple bond (rare, used for some metal complexes)
    let molecule = parse("C$C").expect("Failed to parse quadruple bond");

    assert_eq!(molecule.nodes().len(), 2);
    assert_eq!(molecule.bonds().len(), 1);

    let bond = &molecule.bonds()[0];
    assert_eq!(bond.kind(), BondType::Quadruple);
    assert_eq!(bond.source(), 0);
    assert_eq!(bond.target(), 1);

    // No hydrogens with a quadruple bond
    assert_eq!(molecule.nodes()[0].hydrogens(), 0);
    assert_eq!(molecule.nodes()[1].hydrogens(), 0);
}

#[test]
fn parse_mixed_bonds() {
    // C=C-C#N = acrylonitrile: mix of bonds
    let molecule = parse("C=C-C#N").expect("Failed to parse acrylonitrile");

    assert_eq!(molecule.nodes().len(), 4);
    assert_eq!(molecule.bonds().len(), 3);

    // Double bond C=C
    assert_eq!(molecule.bonds()[0].kind(), BondType::Double);
    assert_eq!(molecule.bonds()[0].source(), 0);
    assert_eq!(molecule.bonds()[0].target(), 1);

    // Single bond C-C
    assert_eq!(molecule.bonds()[1].kind(), BondType::Simple);
    assert_eq!(molecule.bonds()[1].source(), 1);
    assert_eq!(molecule.bonds()[1].target(), 2);

    // Triple bond C#N
    assert_eq!(molecule.bonds()[2].kind(), BondType::Triple);
    assert_eq!(molecule.bonds()[2].source(), 2);
    assert_eq!(molecule.bonds()[2].target(), 3);
}

#[test]
fn parse_explicit_then_implicit_bond() {
    // C=CC = propene
    let molecule = parse("C=CC").expect("Failed to parse propene");

    assert_eq!(molecule.nodes().len(), 3);
    assert_eq!(molecule.bonds().len(), 2);

    // Double bond C=C
    assert_eq!(molecule.bonds()[0].kind(), BondType::Double);
    assert_eq!(molecule.bonds()[0].source(), 0);
    assert_eq!(molecule.bonds()[0].target(), 1);

    // Single bond C-C
    assert_eq!(molecule.bonds()[1].kind(), BondType::Simple);
    assert_eq!(molecule.bonds()[1].source(), 1);
    assert_eq!(molecule.bonds()[1].target(), 2);

    assert_eq!(molecule.nodes()[0].hydrogens(), 2);
    assert_eq!(molecule.nodes()[1].hydrogens(), 1);
    assert_eq!(molecule.nodes()[2].hydrogens(), 3);
}

#[test]
fn parse_aromatic_bond() {
    // c:c = explicit aromatic bond
    let molecule = parse("c:c").expect("Failed to parse aromatic bond");

    assert_eq!(molecule.nodes().len(), 2);
    assert_eq!(molecule.bonds().len(), 1);

    let bond = &molecule.bonds()[0];
    assert_eq!(bond.kind(), BondType::Aromatic);

    // Both atoms must be aromatic
    assert!(molecule.nodes()[0].aromatic());
    assert!(molecule.nodes()[1].aromatic());
}