postgres 0.1.3

A native PostgreSQL driver
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

use postgres::types::array::{DimensionInfo, ArrayBase, Array, MutableArray};

#[test]
fn test_from_vec() {
    let a = ArrayBase::from_vec(vec!(0i, 1, 2), -1);
    assert!([DimensionInfo { len: 3, lower_bound: -1 }][] ==
            a.dimension_info());
    assert_eq!(&0, a.get(-1));
    assert_eq!(&1, a.get(0));
    assert_eq!(&2, a.get(1));
}

#[test]
#[should_fail]
fn test_get_2d_fail() {
    let mut a = ArrayBase::from_vec(vec!(0i, 1, 2), -1);
    a.wrap(1);
    a.get(1);
}

#[test]
#[should_fail]
fn test_2d_slice_range_fail_low() {
    let mut a = ArrayBase::from_vec(vec!(0i, 1, 2), -1);
    a.wrap(1);
    a.slice(0);
}

#[test]
#[should_fail]
fn test_2d_slice_range_fail_high() {
    let mut a = ArrayBase::from_vec(vec!(0i, 1, 2), -1);
    a.wrap(1);
    a.slice(2);
}

#[test]
fn test_2d_slice_get() {
    let mut a = ArrayBase::from_vec(vec!(0i, 1, 2), -1);
    a.wrap(1);
    let s = a.slice(1);
    assert_eq!(&0, s.get(-1));
    assert_eq!(&1, s.get(0));
    assert_eq!(&2, s.get(1));
}

#[test]
#[should_fail]
fn test_push_move_wrong_lower_bound() {
    let mut a = ArrayBase::from_vec(vec!(1i), -1);
    a.push_move(ArrayBase::from_vec(vec!(2), 0));
}

#[test]
#[should_fail]
fn test_push_move_wrong_dims() {
    let mut a = ArrayBase::from_vec(vec!(1i), -1);
    a.wrap(1);
    a.push_move(ArrayBase::from_vec(vec!(1, 2), -1));
}

#[test]
#[should_fail]
fn test_push_move_wrong_dim_count() {
    let mut a = ArrayBase::from_vec(vec!(1i), -1);
    a.wrap(1);
    let mut b = ArrayBase::from_vec(vec!(2), -1);
    b.wrap(1);
    a.push_move(b);
}

#[test]
fn test_push_move_ok() {
    let mut a = ArrayBase::from_vec(vec!(1i, 2), 0);
    a.wrap(0);
    a.push_move(ArrayBase::from_vec(vec!(3, 4), 0));
    let s = a.slice(0);
    assert_eq!(&1, s.get(0));
    assert_eq!(&2, s.get(1));
    let s = a.slice(1);
    assert_eq!(&3, s.get(0));
    assert_eq!(&4, s.get(1));
}

#[test]
fn test_3d() {
    let mut a = ArrayBase::from_vec(vec!(0i, 1), 0);
    a.wrap(0);
    a.push_move(ArrayBase::from_vec(vec!(2, 3), 0));
    a.wrap(0);
    let mut b = ArrayBase::from_vec(vec!(4, 5), 0);
    b.wrap(0);
    b.push_move(ArrayBase::from_vec(vec!(6, 7), 0));
    a.push_move(b);
    let s1 = a.slice(0);
    let s2 = s1.slice(0);
    assert_eq!(&0, s2.get(0));
    assert_eq!(&1, s2.get(1));
    let s2 = s1.slice(1);
    assert_eq!(&2, s2.get(0));
    assert_eq!(&3, s2.get(1));
    let s1 = a.slice(1);
    let s2 = s1.slice(0);
    assert_eq!(&4, s2.get(0));
    assert_eq!(&5, s2.get(1));
    let s2 = s1.slice(1);
    assert_eq!(&6, s2.get(0));
    assert_eq!(&7, s2.get(1));
}

#[test]
fn test_mut() {
    let mut a = ArrayBase::from_vec(vec!(1i, 2), 0);
    a.wrap(0);
    {
        let mut s = a.slice_mut(0);
        *s.get_mut(0) = 3;
    }
    let s = a.slice(0);
    assert_eq!(&3, s.get(0));
}

#[test]
#[should_fail]
fn test_base_overslice() {
    let a = ArrayBase::from_vec(vec!(1i), 0);
    a.slice(0);
}

#[test]
#[should_fail]
fn test_slice_overslice() {
    let mut a = ArrayBase::from_vec(vec!(1i), 0);
    a.wrap(0);
    let s = a.slice(0);
    s.slice(0);
}