GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: unittest/data.cpp Lines: 55 55 100.0 %
Date: 2024-01-23 21:41:47 Branches: 298 584 51.0 %

Line Branch Exec Source
1
//
2
// Copyright (c) 2019-2020 INRIA
3
//
4
5
#include "pinocchio/multibody/data.hpp"
6
#include "pinocchio/multibody/model.hpp"
7
#include "pinocchio/parsers/sample-models.hpp"
8
9
#include "pinocchio/algorithm/check.hpp"
10
11
#include <boost/test/unit_test.hpp>
12
#include <boost/utility/binary.hpp>
13
14
using namespace pinocchio;
15
16
BOOST_AUTO_TEST_SUITE(BOOST_TEST_MODULE)
17
18
















4
  BOOST_AUTO_TEST_CASE(test_empty_model)
19
  {
20
4
    Model empty_model;
21
4
    Data empty_data(empty_model);
22
23



2
    BOOST_CHECK(empty_model.check(empty_data));
24
2
  }
25
26
















4
  BOOST_AUTO_TEST_CASE(test_data_start_idx_v_fromRow)
27
  {
28
4
    Model model;
29
2
    buildModels::humanoidRandom(model);
30
31
4
    Data data(model);
32
33
56
    for(Model::JointIndex joint_id = 1; joint_id < (Model::JointIndex)model.njoints; ++joint_id)
34
    {
35
54
      const int nv_joint = model.joints[joint_id].nv();
36
54
      const int idx_joint = model.joints[joint_id].idx_v();
37
38
118
      for(int k = 0; k < nv_joint; ++k)
39
      {
40



64
        BOOST_CHECK(data.start_idx_v_fromRow[(size_t)(idx_joint+k)] == idx_joint);
41



64
        BOOST_CHECK(data.end_idx_v_fromRow[(size_t)(idx_joint+k)] == idx_joint+nv_joint-1);
42
      }
43
    }
44
2
  }
45
46
















4
  BOOST_AUTO_TEST_CASE(test_data_supports_fromRow)
47
  {
48
4
    Model model;
49
2
    buildModels::humanoidRandom(model);
50
51
4
    Data data(model);
52
53
66
    for(size_t k = 0; k < (size_t)model.nv; ++k)
54
    {
55
64
      const std::vector<int> & support = data.supports_fromRow[k];
56
64
      const int parent_id = data.parents_fromRow[k];
57
58
64
      if(parent_id >= 0)
59
      {
60
62
        const std::vector<int> & support_parent = data.supports_fromRow[(size_t)parent_id];
61



62
        BOOST_CHECK(support.size() == support_parent.size()+1);
62
574
        for(size_t j = 0; j < support_parent.size(); ++j)
63
        {
64



512
          BOOST_CHECK(support[j] == support_parent[j]);
65
        }
66
      }
67
68



64
      BOOST_CHECK(support.back() == (int)k);
69
    }
70
2
  }
71
72
















4
  BOOST_AUTO_TEST_CASE(test_copy_and_equal_op)
73
  {
74
4
    Model model;
75
2
    buildModels::humanoidRandom(model);
76
77
4
    Data data(model);
78
4
    Data data_copy = data;
79
80



2
    BOOST_CHECK(data == data);
81



2
    BOOST_CHECK(data == data_copy);
82
83
2
    data_copy.oMi[0].setRandom();
84



2
    BOOST_CHECK(data != data_copy);
85
2
  }
86
87
















4
  BOOST_AUTO_TEST_CASE(test_container_aligned_vector)
88
  {
89
4
    Model model;
90
2
    buildModels::humanoidRandom(model);
91
92
4
    Data data(model);
93
94
2
    container::aligned_vector<Data::Force> & f = data.f;
95
2
    data.f[0].setRandom();
96
97



2
    BOOST_CHECK(data.f[0] == f[0]);
98
2
  }
99
100
















4
  BOOST_AUTO_TEST_CASE(test_std_vector_of_Data)
101
  {
102
4
    Model model;
103
2
    buildModels::humanoidRandom(model);
104
105
4
    PINOCCHIO_ALIGNED_STD_VECTOR(Data) datas;
106
42
    for(size_t k = 0; k < 20; ++k)
107

40
      datas.push_back(Data(model));
108
2
  }
109
110
BOOST_AUTO_TEST_SUITE_END()