netcdf3 0.6.1

A pure Rust library for reading and writing NetCDF-3 files
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

#![cfg(test)]

use crate::{Dimension, DimensionType};
use std::rc::Rc;

#[test]
fn test_dim_new_fixed_size() {
    const DIM_NAME: &str = "dim_1";
    const DIM_SIZE: usize = 10;

    let dim = Dimension::new_fixed_size(DIM_NAME, DIM_SIZE).unwrap();

    assert_eq!(DIM_NAME, dim.name());
    assert_eq!(DIM_SIZE, dim.size());
    assert_eq!(DimensionType::FixedSize, dim.dim_type());
    assert_eq!(true, dim.is_fixed());
    assert_eq!(false, dim.is_unlimited())
}

#[test]
fn test_dim_new_unlimited_size() {
    const DIM_NAME: &str = "dim_1";
    const DIM_SIZE: usize = 10;

    let dim = Dimension::new_unlimited_size(DIM_NAME, DIM_SIZE).unwrap();

    assert_eq!(DIM_NAME, dim.name());
    assert_eq!(DIM_SIZE, dim.size());
    assert_eq!(DimensionType::UnlimitedSize, dim.dim_type());
    assert_eq!(false, dim.is_fixed());
    assert_eq!(true, dim.is_unlimited());
}

#[test]
fn test_dim_equality() {
    // test equality between 2 fixed-size dimension
    {
        let dim_a: Dimension = Dimension::new_fixed_size("name_1", 180).unwrap();
        let dim_b: Dimension = Dimension::new_fixed_size("name_1", 180).unwrap();
        assert_eq!(dim_a, dim_b);
    }

    // test equality between 2 fixed-size dimension with different sizes
    {
        let dim_a: Dimension = Dimension::new_fixed_size("name_1", 90).unwrap();
        let dim_b: Dimension = Dimension::new_fixed_size("name_1", 180).unwrap();
        assert_ne!(dim_a, dim_b);
    }

    // test equality between 2 fixed-size dimension with different names
    {
        let dim_a: Dimension = Dimension::new_fixed_size("name_1", 180).unwrap();
        let dim_b: Dimension = Dimension::new_fixed_size("name_2", 180).unwrap();
        assert_ne!(dim_a, dim_b);
    }

    // test equality between 2 unlimited-size dimension
    {
        let dim_a: Dimension = Dimension::new_unlimited_size("name_1", 180).unwrap();
        let dim_b: Dimension = Dimension::new_unlimited_size("name_1", 180).unwrap();
        assert_eq!(dim_a, dim_b);
    }

    // test equality between 2 unlimited-size dimension with different sizes
    {
        let dim_a: Dimension = Dimension::new_unlimited_size("name_1", 90).unwrap();
        let dim_b: Dimension = Dimension::new_unlimited_size("name_1", 180).unwrap();
        assert_ne!(dim_a, dim_b);
    }

    // test equality between 2 unlimited-size dimension with different names
    {
        let dim_a: Dimension = Dimension::new_unlimited_size("name_1", 180).unwrap();
        let dim_b: Dimension = Dimension::new_unlimited_size("name_2", 180).unwrap();
        assert_ne!(dim_a, dim_b);
    }

    // test equality between 1 unlimited-size dimension and 1 fixed-size dimension
    {
        let dim_a: Dimension = Dimension::new_fixed_size("name_1", 180).unwrap();
        let dim_b: Dimension = Dimension::new_unlimited_size("name_1", 180).unwrap();
        assert_ne!(dim_a, dim_b);
    }
}

#[test]
fn test_rc_dim_equality() {
    // test equality between 2 fixed-size dimensions
    {
        let dim_a: Rc<Dimension> = Rc::new(Dimension::new_fixed_size("name_1", 180).unwrap());
        let dim_b: Rc<Dimension> = Rc::new(Dimension::new_fixed_size("name_1", 180).unwrap());

        assert_eq!(dim_a, dim_b);
        assert!(!Rc::ptr_eq(&dim_a, &dim_b));

        let dim_c: Rc<Dimension> = Rc::clone(&dim_a);
        assert_eq!(dim_a, dim_c);
        assert_eq!(dim_b, dim_c);
        assert!(Rc::ptr_eq(&dim_a, &dim_c));
        assert!(!Rc::ptr_eq(&dim_b, &dim_c));
    }
}