Grcov report - test

1

//! Functions in this module are only relevant for testing purposes.

2

3

use rand::Rng;

4

use std::collections::HashSet;

5

6

use crate::Ldd;

7

use crate::Storage;

8

use crate::Value;

9

use crate::iterators::*;

10

use crate::operations::*;

11

12

/// Returns a vector of the given length with random u64 values (from 0..max_value).

13

156000

pub fn random_vector(rng: &mut impl Rng, length: usize, max_value: Value) -> Vec<Value> {

14

156000

    let mut vector: Vec<Value> = Vec::new();

15

1534602

    for _ in 0..length {

16

1534602

        vector.push(rng.random_range(0..max_value));

17

1534602

18

19

156000

    vector

20

156000

21

22

/// Returns a sorted vector of the given length with unique u64 values (from 0..max_value).

23

500

pub fn random_sorted_vector(rng: &mut impl Rng, length: usize, max_value: Value) -> Vec<Value> {

24

    use rand::prelude::IteratorRandom;

25

26

500

    let mut result = (0..max_value).choose_multiple(rng, length);

27

500

    result.sort();

28

500

    result

29

500

30

31

/// Returns a set of 'amount' vectors where every vector has the given length.

32

3720

pub fn random_vector_set(rng: &mut impl Rng, amount: usize, length: usize, max_value: Value) -> HashSet<Vec<Value>> {

33

3720

    let mut result: HashSet<Vec<Value>> = HashSet::new();

34

35

    // Insert 'amount' number of vectors into the result.

36

152800

    for _ in 0..amount {

37

152800

        result.insert(random_vector(rng, length, max_value));

38

152800

39

40

3720

    result

41

3720

42

43

/// Returns an LDD containing all elements of the given iterator over vectors.

44

4220

pub fn from_iter<'a, I>(storage: &mut Storage, iter: I) -> Ldd

45

4220

where

46

4220

    I: Iterator<Item = &'a Vec<Value>>,

47

48

4220

    let mut result = storage.empty_set().clone();

49

50

248784

    for vector in iter {

51

248784

        let single = singleton(storage, vector);

52

248784

        result = union(storage, &result, &single);

53

248784

54

55

4220

    result

56

4220

57

58

/// Prints vectors included in left, but not in right. Returns true iff the difference is non-empty.

59

200

pub fn print_left(storage: &Storage, left: &Ldd, right: &Ldd) -> bool {

60

200

    let mut result = true;

61

62

6400

    for element in iter(storage, left) {

63

6400

        if !element_of(storage, &element, right) {

64

            result = false;

65

            eprintln!("{:?}", element);

66

6400

67

68

69

200

    result

70

200

71

72

/// Prints the differences in contained vectors between two LDDs.

73

100

pub fn print_differences(storage: &Storage, left: &Ldd, right: &Ldd) {

74

    // eprintln!("Vectors contained in {:?}, but not in {:?}:", left, right);

75

100

    print_left(storage, left, right);

76

77

    // eprintln!("Vectors contained in {}, but not in {}:", right, left);

78

100

    print_left(storage, right, left);

79

100

80

81

/// Returns project(vector, proj), see [project]. Requires proj to be sorted.

82

207488

pub fn project_vector(vector: &[Value], proj: &[Value]) -> Vec<Value> {

83

207488

    let mut result = Vec::<Value>::new();

84

421376

    for i in proj {

85

421376

        result.push(vector[*i as usize]);

86

421376

87

207488

    result

88

207488