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

//! Stoichiometry tests (disconnected structures)
//!
//! These tests verify the parsing of molecules with the `.` separator:
//! - Simple disconnected molecules `C.C`
//! - Ionic compounds `[Na+].[Cl-]`
//! - Complex mixtures

use opensmiles::{parse, AtomSymbol, OrganicAtom};

#[test]
fn parse_disconnected_simple() {
    // C.C = two separate methane molecules
    let molecule = parse("C.C").expect("Failed to parse C.C");

    assert_eq!(molecule.nodes().len(), 2);
    assert_eq!(molecule.bonds().len(), 0); // No bond between the two
}

#[test]

fn parse_disconnected_ionic() {
    // [Na+].[Cl-] = sodium chloride (salt)
    let molecule = parse("[Na+].[Cl-]").expect("Failed to parse NaCl");

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

    assert_eq!(*molecule.nodes()[0].atom().element(), AtomSymbol::Na);
    assert_eq!(molecule.nodes()[0].atom().charge(), 1);

    assert_eq!(
        *molecule.nodes()[1].atom().element(),
        AtomSymbol::Organic(OrganicAtom::Cl)
    );
    assert_eq!(molecule.nodes()[1].atom().charge(), -1);
}

#[test]

fn parse_disconnected_multiple() {
    // C.C.C = three methane molecules
    let molecule = parse("C.C.C").expect("Failed to parse C.C.C");

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

#[test]

fn parse_disconnected_complex() {
    // CC.CC = two ethane molecules
    let molecule = parse("CC.CC").expect("Failed to parse CC.CC");

    assert_eq!(molecule.nodes().len(), 4);
    assert_eq!(molecule.bonds().len(), 2); // One bond per ethane molecule

    // Check that bonds are in the correct molecules
    let bond0 = &molecule.bonds()[0];
    let bond1 = &molecule.bonds()[1];

    // First bond: between atoms 0 and 1
    assert_eq!(bond0.source(), 0);
    assert_eq!(bond0.target(), 1);

    // Second bond: between atoms 2 and 3
    assert_eq!(bond1.source(), 2);
    assert_eq!(bond1.target(), 3);
}

#[test]

fn parse_disconnected_with_branches() {
    // CC(C)C.CC = isobutane + ethane
    let molecule = parse("CC(C)C.CC").expect("Failed to parse CC(C)C.CC");

    assert_eq!(molecule.nodes().len(), 6);
    assert_eq!(molecule.bonds().len(), 4); // 3 for isobutane + 1 for ethane
}

#[test]

fn parse_water_hydronium() {
    // [OH2].[H+] = water + proton (acid)
    let molecule = parse("[OH2].[H+]").expect("Failed to parse water + hydronium");

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

    // Water
    assert_eq!(
        *molecule.nodes()[0].atom().element(),
        AtomSymbol::Organic(OrganicAtom::O)
    );
    assert_eq!(molecule.nodes()[0].hydrogens(), 2);

    // Proton
    assert_eq!(*molecule.nodes()[1].atom().element(), AtomSymbol::H);
    assert_eq!(molecule.nodes()[1].atom().charge(), 1);
}

#[test]

fn parse_hydrate() {
    // CCO.[OH2] = ethanol + water (representation of a hydrate)
    let molecule = parse("CCO.[OH2]").expect("Failed to parse ethanol hydrate");

    assert_eq!(molecule.nodes().len(), 4); // 3 for ethanol + 1 for water
    assert_eq!(molecule.bonds().len(), 2); // Only ethanol bonds
}

#[test]

fn parse_metal_complex() {
    // [Cu+2].[O-].[O-] = copper(II) oxide
    let molecule = parse("[Cu+2].[O-].[O-]").expect("Failed to parse copper oxide");

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

    assert_eq!(*molecule.nodes()[0].atom().element(), AtomSymbol::Cu);
    assert_eq!(molecule.nodes()[0].atom().charge(), 2);

    for i in 1..=2 {
        assert_eq!(
            *molecule.nodes()[i].atom().element(),
            AtomSymbol::Organic(OrganicAtom::O)
        );
        assert_eq!(molecule.nodes()[i].atom().charge(), -1);
    }
}