rxing 0.9.0

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
110
111

/*
* Copyright 2017 Huy Cuong Nguyen
* Copyright 2007 ZXing authors
*/
// SPDX-License-Identifier: Apache-2.0

use crate::{common::BitMatrix, qrcode::cpp_port::data_mask::GetMaskedBit};

#[test]
fn Mask0() {
    TestMaskAcrossDimensions(0, |i, j| (i + j) % 2 == 0);
}

#[test]
fn Mask1() {
    TestMaskAcrossDimensions(1, |i, _| i % 2 == 0);
}

#[test]
fn Mask2() {
    TestMaskAcrossDimensions(2, |_, j| j % 3 == 0);
}

#[test]
fn Mask3() {
    TestMaskAcrossDimensions(3, |i, j| (i + j) % 3 == 0);
}

#[test]
fn Mask4() {
    TestMaskAcrossDimensions(4, |i, j| (i / 2 + j / 3) % 2 == 0);
}

#[test]
fn Mask5() {
    TestMaskAcrossDimensions(5, |i, j| (i * j) % 2 + (i * j) % 3 == 0);
}

#[test]
fn Mask6() {
    TestMaskAcrossDimensions(6, |i, j| ((i * j) % 2 + (i * j) % 3) % 2 == 0);
}

#[test]
fn Mask7() {
    TestMaskAcrossDimensions(7, |i, j| ((i + j) % 2 + (i * j) % 3) % 2 == 0);
}

#[test]
fn MicroMask0() {
    TestMicroMaskAcrossDimensions(0, |i, _| i % 2 == 0);
}

#[test]
fn MicroMask1() {
    TestMicroMaskAcrossDimensions(1, |i, j| (i / 2 + j / 3) % 2 == 0);
}

#[test]
fn MicroMask2() {
    TestMicroMaskAcrossDimensions(2, |i, j| ((i * j) % 2 + (i * j) % 3) % 2 == 0);
}

#[test]
fn MicroMask3() {
    TestMicroMaskAcrossDimensions(3, |i, j| ((i + j) % 2 + (i * j) % 3) % 2 == 0);
}

fn TestMaskAcrossDimensionsImpl<F>(
    maskIndex: u32,
    isMicro: bool,
    versionMax: u32,
    dimensionStart: u32,
    dimensionStep: u32,
    condition: F,
) where
    F: Fn(u32, u32) -> bool,
{
    for version in 1..=versionMax {
        // for (int version = 1; version <= versionMax; version++) {
        let dimension = dimensionStart + dimensionStep * version;
        let bits = BitMatrix::with_single_dimension(dimension).expect("couldn't create bitmatrix");

        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!(
                    GetMaskedBit(&bits, j, i, maskIndex, Some(isMicro))
                        .expect("could not get mask bit"),
                    condition(i, j),
                    "({i},{j})"
                );
            }
        }
    }
}

fn TestMaskAcrossDimensions<F>(maskIndex: u32, condition: F)
where
    F: Fn(u32, u32) -> bool,
{
    TestMaskAcrossDimensionsImpl(maskIndex, false, 40, 17, 4, condition);
}

fn TestMicroMaskAcrossDimensions<F>(maskIndex: u32, condition: F)
where
    F: Fn(u32, u32) -> bool,
{
    TestMaskAcrossDimensionsImpl(maskIndex, true, 4, 9, 2, condition);
}