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 rand::RngExt;

7

use streaming_iterator::StreamingIterator;

8

9

use crate::Ldd;

10

use crate::Storage;

11

use crate::Value;

12

use crate::iterators::*;

13

use crate::operations::*;

14

15

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

16

205600

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

17

205600

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

18

1996405

    for _ in 0..length {

19

1996405

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

20

1996405

21

22

205600

    vector

23

205600

24

25

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

26

500

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

27

    use rand::prelude::IteratorRandom;

28

29

500

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

30

500

    result.sort();

31

500

    result

32

500

33

34

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

35

5520

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

36

5520

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

37

38

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

39

202400

    for _ in 0..amount {

40

202400

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

41

202400

42

43

5520

    result

44

5520

45

46

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

47

6320

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

48

6320

where

49

6320

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

50

51

6320

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

52

53

297611

    for vector in iter {

54

297611

        let single = singleton(storage, vector);

55

297611

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

56

297611

57

58

6320

    result

59

6320

60

61

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

62

200

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

63

200

    let mut result = true;

64

65

200

    let mut iter = iter(storage, left);

66

6600

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

67

6400

        if !element_of(storage, element, right) {

68

            result = false;

69

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

70

6400

71

72

73

200

    result

74

200

75

76

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

77

100

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

78

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

79

100

    print_left(storage, left, right);

80

81

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

82

100

    print_left(storage, right, left);

83

100

84

85

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

86

207744

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

87

207744

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

88

421888

    for i in proj {

89

421888

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

90

421888

91

207744

    result

92

207744