rxing 0.4.11

A rust port of the zxing barcode library.
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

/*
 * Copyright 2007 ZXing authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use crate::common::BitMatrix;

use super::DataMask;

/**
 * @author Sean Owen
 */

type MaskCondition = fn(u32, u32) -> bool;

#[test]
fn testMask0() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_000, |i, j| ((i + j) % 2 == 0));
    testMaskAcrossDimensionsU8(0, |i, j| ((i + j) % 2 == 0));
}

#[test]
fn testMask1() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_001, |i, _j| i % 2 == 0);
    testMaskAcrossDimensionsU8(1, |i, _j| i % 2 == 0);
}

#[test]
fn testMask2() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_010, |_i, j| j % 3 == 0);
    testMaskAcrossDimensionsU8(2, |_i, j| j % 3 == 0);
}

#[test]
fn testMask3() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_011, |i, j| (i + j) % 3 == 0);
    testMaskAcrossDimensionsU8(3, |i, j| (i + j) % 3 == 0);
}

#[test]
fn testMask4() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_100, |i, j| (i / 2 + j / 3) % 2 == 0);
    testMaskAcrossDimensionsU8(4, |i, j| (i / 2 + j / 3) % 2 == 0);
}

#[test]
fn testMask5() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_101, |i, j| {
        (i * j) % 2 + (i * j) % 3 == 0
    });
    testMaskAcrossDimensionsU8(5, |i, j| (i * j) % 2 + (i * j) % 3 == 0);
}

#[test]
fn testMask6() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_110, |i, j| {
        ((i * j) % 2 + (i * j) % 3) % 2 == 0
    });
    testMaskAcrossDimensionsU8(6, |i, j| ((i * j) % 2 + (i * j) % 3) % 2 == 0);
}

#[test]
fn testMask7() {
    testMaskAcrossDimensions(DataMask::DATA_MASK_111, |i, j| {
        ((i + j) % 2 + (i * j) % 3) % 2 == 0
    });
    testMaskAcrossDimensionsU8(7, |i, j| ((i + j) % 2 + (i * j) % 3) % 2 == 0);
}

fn testMaskAcrossDimensionsU8(mask: u8, condition: MaskCondition) {
    testMaskAcrossDimensions(mask.try_into().unwrap(), condition)
}

fn testMaskAcrossDimensions(mask: DataMask, condition: MaskCondition) {
    // let mask = DataMask.values()[reference];
    for version in 1..=40 {
        // for (int version = 1; version <= 40; version++) {
        let dimension = 17 + 4 * version;
        testMask(mask, dimension, condition);
    }
}

fn testMask(mask: DataMask, dimension: u32, condition: MaskCondition) {
    let mut bits = BitMatrix::with_single_dimension(dimension).expect("new");
    mask.unmaskBitMatrix(&mut bits, dimension);
    for i in 0..dimension {
        // for (int i = 0; i < dimension; i++) {
        for j in 0..dimension {
            // for (int j = 0; j < dimension; j++) {
            assert_eq!(condition(i, j), bits.get(j, i), "({i},{j})");
        }
    }
}

// @FunctionalInterface
// private interface MaskCondition {
//   boolean isMasked(int i, int j);
// }