-
Notifications
You must be signed in to change notification settings - Fork 1.2k
/
scalar_view_dense_output_test.cc
103 lines (88 loc) · 3.59 KB
/
scalar_view_dense_output_test.cc
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
#include "drake/systems/analysis/scalar_view_dense_output.h"
#include <gtest/gtest.h>
#include "drake/common/autodiff.h"
#include "drake/common/eigen_types.h"
#include "drake/common/test_utilities/expect_throws_message.h"
#include "drake/systems/analysis/hermitian_dense_output.h"
namespace drake {
namespace systems {
namespace analysis {
namespace {
template <typename T>
class ScalarViewDenseOutputTest : public ::testing::Test {
protected:
std::unique_ptr<DenseOutput<T>> CreateDummyDenseOutput() {
auto dense_output =
std::make_unique<HermitianDenseOutput<T>>();
typename HermitianDenseOutput<T>::IntegrationStep step(
this->kInitialTime, this->kInitialState, this->kInitialStateDerivative);
step.Extend(this->kFinalTime, this->kFinalState,
this->kFinalStateDerivative);
dense_output->Update(std::move(step));
dense_output->Consolidate();
return dense_output;
}
const double kInvalidTime{-1.0};
const double kInitialTime{0.0};
const double kMidTime{0.5};
const double kFinalTime{1.0};
const MatrixX<double> kInitialState{
(MatrixX<double>(3, 1) << 0., 0., 0.).finished()};
const MatrixX<T> kFinalState{
(MatrixX<double>(3, 1) << 1., 10., 100.).finished()};
const MatrixX<double> kInitialStateDerivative{
(MatrixX<double>(3, 1) << 0., 1., 0.).finished()};
const MatrixX<double> kFinalStateDerivative{
(MatrixX<double>(3, 1) << 1., 0., 1.).finished()};
const int kValidElementIndex{0};
const int kInvalidElementIndex{10};
};
typedef ::testing::Types<double, AutoDiffXd> ExtensionTypes;
TYPED_TEST_SUITE(ScalarViewDenseOutputTest, ExtensionTypes);
// Checks that ScalarViewDenseOutput properly wraps a
// DenseOutput instance.
TYPED_TEST(ScalarViewDenseOutputTest, ExtensionConsistency) {
// Verifies that passing a null base dense output results in an error.
DRAKE_EXPECT_THROWS_MESSAGE(
ScalarViewDenseOutput<TypeParam>(
std::unique_ptr<HermitianDenseOutput<TypeParam>>(),
this->kValidElementIndex),
".*dense output.*is null.*");
// Verifies that views to invalid elements result in an error.
DRAKE_EXPECT_THROWS_MESSAGE(
ScalarViewDenseOutput<TypeParam>(
this->CreateDummyDenseOutput(), this->kInvalidElementIndex),
".*out of.*dense output.*range.*");
// Instantiates scalar continuous extension properly.
ScalarViewDenseOutput<TypeParam> dense_output(
this->CreateDummyDenseOutput(), this->kValidElementIndex);
// Retrieves dummy base continuous extension.
const DenseOutput<TypeParam>* base_output =
dense_output.get_base_output();
// Checks basic getters for consistency.
EXPECT_EQ(dense_output.is_empty(),
base_output->is_empty());
EXPECT_EQ(dense_output.start_time(),
base_output->start_time());
EXPECT_EQ(dense_output.end_time(),
base_output->end_time());
EXPECT_EQ(dense_output.size(), 1);
// Checks evaluation preconditions.
DRAKE_EXPECT_THROWS_MESSAGE(
dense_output.Evaluate(this->kInvalidTime),
".*[Tt]ime.*out of.*dense output.*domain.*");
// Compares evaluations for consistency.
EXPECT_EQ(
dense_output.EvaluateScalar(this->kInitialTime),
base_output->EvaluateNth(this->kInitialTime, this->kValidElementIndex));
EXPECT_EQ(
dense_output.EvaluateScalar(this->kMidTime),
base_output->EvaluateNth(this->kMidTime, this->kValidElementIndex));
EXPECT_EQ(
dense_output.EvaluateScalar(this->kFinalTime),
base_output->EvaluateNth(this->kFinalTime, this->kValidElementIndex));
}
} // namespace
} // namespace analysis
} // namespace systems
} // namespace drake