Grcov report - test

1

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

2

3

use rand::Rng;

4

use streaming_iterator::StreamingIterator;

5

use std::collections::HashSet;

6

7

use crate::Ldd;

8

use crate::Storage;

9

use crate::Value;

10

use crate::iterators::*;

11

use crate::operations::*;

12

13

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

14

190600

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

15

190600

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

16

1848177

    for _ in 0..length {

17

1848177

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

18

1848177

19

20

190600

    vector

21

190600

22

23

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

24

500

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

25

    use rand::prelude::IteratorRandom;

26

27

500

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

28

500

    result.sort();

29

500

    result

30

500

31

32

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

33

4920

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

34

4920

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

35

36

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

37

187400

    for _ in 0..amount {

38

187400

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

39

187400

40

41

4920

    result

42

4920

43

44

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

45

5620

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

46

5620

where

47

5620

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

48

49

5620

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

50

51

282554

    for vector in iter {

52

282554

        let single = singleton(storage, vector);

53

282554

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

54

282554

55

56

5620

    result

57

5620

58

59

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

60

200

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

61

200

    let mut result = true;

62

63

200

    let mut iter = iter(storage, left);

64

6600

    while let Some(element) = iter.next() {

65

6400

        if !element_of(storage, element, right) {

66

            result = false;

67

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

68

6400

69

70

71

200

    result

72

200

73

74

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

75

100

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

76

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

77

100

    print_left(storage, left, right);

78

79

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

80

100

    print_left(storage, right, left);

81

100

82

83

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

84

207616

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

85

207616

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

86

421632

    for i in proj {

87

421632

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

88

421632

89

207616

    result

90

207616