Coverage Report

Created: 2025-11-07 07:06

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/basicstuff_fuzzer.cc
Line
Count
Source
1
// Copyright 2020 Google LLC
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
15
#include <fuzzer/FuzzedDataProvider.h>
16
17
#include "Eigen/Core"
18
19
namespace {
20
21
static constexpr Eigen::Index kEigenTestMaxSize = 64;
22
static constexpr Eigen::Index kEigenIndexOne = static_cast<Eigen::Index>(1);
23
24
template <typename T>
25
796k
T ConsumeValue(FuzzedDataProvider* stream) {
26
796k
  return stream->ConsumeIntegral<T>();
27
796k
}
28
29
template <>
30
795k
float ConsumeValue(FuzzedDataProvider* stream) {
31
795k
  return stream->ConsumeFloatingPoint<float>();
32
795k
}
33
34
template <>
35
675k
double ConsumeValue(FuzzedDataProvider* stream) {
36
675k
  return stream->ConsumeFloatingPoint<double>();
37
675k
}
38
39
template <>
40
1.16M
long double ConsumeValue(FuzzedDataProvider* stream) {
41
1.16M
  return stream->ConsumeFloatingPoint<long double>();
42
1.16M
}
43
44
template <>
45
512k
std::complex<float> ConsumeValue(FuzzedDataProvider* stream) {
46
512k
  return std::complex<float>(stream->ConsumeFloatingPoint<float>(),
47
512k
                             stream->ConsumeFloatingPoint<float>());
48
512k
}
49
50
template <>
51
966k
std::complex<double> ConsumeValue(FuzzedDataProvider* stream) {
52
966k
  return std::complex<float>(stream->ConsumeFloatingPoint<double>(),
53
966k
                             stream->ConsumeFloatingPoint<double>());
54
966k
}
55
56
template <typename MatrixType>
57
MatrixType GenerateTestMatrix(size_t rows, size_t cols,
58
29.2k
                              FuzzedDataProvider* stream) {
59
29.2k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
4.90M
  for (auto& value : test_data) {
61
4.90M
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
4.90M
  }
63
29.2k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
29.2k
  return MatrixType(mapped_map);
65
29.2k
}
basicstuff_fuzzer.cc:Eigen::Matrix<std::__1::complex<float>, -1, -1, 0, -1, -1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<std::__1::complex<float>, -1, -1, 0, -1, -1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
4.39k
                              FuzzedDataProvider* stream) {
59
4.39k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
504k
  for (auto& value : test_data) {
61
504k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
504k
  }
63
4.39k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
4.39k
  return MatrixType(mapped_map);
65
4.39k
}
basicstuff_fuzzer.cc:Eigen::Matrix<std::__1::complex<float>, -1, 1, 0, -1, 1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<std::__1::complex<float>, -1, 1, 0, -1, 1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
1.46k
                              FuzzedDataProvider* stream) {
59
1.46k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
6.33k
  for (auto& value : test_data) {
61
6.33k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
6.33k
  }
63
1.46k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
1.46k
  return MatrixType(mapped_map);
65
1.46k
}
basicstuff_fuzzer.cc:Eigen::Matrix<int, -1, -1, 0, -1, -1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
4.39k
                              FuzzedDataProvider* stream) {
59
4.39k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
787k
  for (auto& value : test_data) {
61
787k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
787k
  }
63
4.39k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
4.39k
  return MatrixType(mapped_map);
65
4.39k
}
basicstuff_fuzzer.cc:Eigen::Matrix<int, -1, 1, 0, -1, 1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<int, -1, 1, 0, -1, 1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
1.46k
                              FuzzedDataProvider* stream) {
59
1.46k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
7.85k
  for (auto& value : test_data) {
61
7.85k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
7.85k
  }
63
1.46k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
1.46k
  return MatrixType(mapped_map);
65
1.46k
}
basicstuff_fuzzer.cc:Eigen::Matrix<std::__1::complex<double>, -1, -1, 0, -1, -1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<std::__1::complex<double>, -1, -1, 0, -1, -1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
4.39k
                              FuzzedDataProvider* stream) {
59
4.39k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
955k
  for (auto& value : test_data) {
61
955k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
955k
  }
63
4.39k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
4.39k
  return MatrixType(mapped_map);
65
4.39k
}
basicstuff_fuzzer.cc:Eigen::Matrix<std::__1::complex<double>, -1, 1, 0, -1, 1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<std::__1::complex<double>, -1, 1, 0, -1, 1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
1.46k
                              FuzzedDataProvider* stream) {
59
1.46k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
9.71k
  for (auto& value : test_data) {
61
9.71k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
9.71k
  }
63
1.46k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
1.46k
  return MatrixType(mapped_map);
65
1.46k
}
basicstuff_fuzzer.cc:Eigen::Matrix<long double, -1, -1, 0, -1, -1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<long double, -1, -1, 0, -1, -1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
4.39k
                              FuzzedDataProvider* stream) {
59
4.39k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
1.15M
  for (auto& value : test_data) {
61
1.15M
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
1.15M
  }
63
4.39k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
4.39k
  return MatrixType(mapped_map);
65
4.39k
}
basicstuff_fuzzer.cc:Eigen::Matrix<long double, -1, 1, 0, -1, 1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<long double, -1, 1, 0, -1, 1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
1.46k
                              FuzzedDataProvider* stream) {
59
1.46k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
10.9k
  for (auto& value : test_data) {
61
10.9k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
10.9k
  }
63
1.46k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
1.46k
  return MatrixType(mapped_map);
65
1.46k
}
basicstuff_fuzzer.cc:Eigen::Matrix<float, -1, -1, 0, -1, -1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<float, -1, -1, 0, -1, -1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
2.92k
                              FuzzedDataProvider* stream) {
59
2.92k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
795k
  for (auto& value : test_data) {
61
795k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
795k
  }
63
2.92k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
2.92k
  return MatrixType(mapped_map);
65
2.92k
}
basicstuff_fuzzer.cc:Eigen::Matrix<double, -1, -1, 0, -1, -1> (anonymous namespace)::GenerateTestMatrix<Eigen::Matrix<double, -1, -1, 0, -1, -1> >(unsigned long, unsigned long, FuzzedDataProvider*)
Line
Count
Source
58
2.92k
                              FuzzedDataProvider* stream) {
59
2.92k
  std::vector<typename MatrixType::value_type> test_data(rows * cols);
60
675k
  for (auto& value : test_data) {
61
675k
    value = ConsumeValue<typename MatrixType::value_type>(stream);
62
675k
  }
63
2.92k
  Eigen::Map<MatrixType> mapped_map(test_data.data(), rows, cols);
64
2.92k
  return MatrixType(mapped_map);
65
2.92k
}
66
67
template <typename MatrixType>
68
5.85k
void basicStuff(const MatrixType& m, FuzzedDataProvider* stream) {
69
5.85k
  typedef typename MatrixType::Scalar Scalar;
70
5.85k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
71
5.85k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
72
5.85k
                        MatrixType::RowsAtCompileTime>
73
5.85k
      SquareMatrixType;
74
75
5.85k
  Eigen::Index rows = m.rows();
76
5.85k
  Eigen::Index cols = m.cols();
77
78
5.85k
  MatrixType m1 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
79
5.85k
             m2 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
80
5.85k
             m3(rows, cols), mzero = MatrixType::Zero(rows, cols),
81
5.85k
             square = GenerateTestMatrix<
82
5.85k
                 Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
83
5.85k
                               MatrixType::RowsAtCompileTime>>(rows, rows,
84
5.85k
                                                               stream);
85
5.85k
  VectorType v1 = GenerateTestMatrix<VectorType>(rows, 1, stream),
86
5.85k
             vzero = VectorType::Zero(rows);
87
5.85k
  SquareMatrixType sm1 = SquareMatrixType::Random(rows, rows), sm2(rows, rows);
88
89
5.85k
  Scalar x = ConsumeValue<typename MatrixType::Scalar>(stream);
90
91
5.85k
  Eigen::Index r = stream->ConsumeIntegralInRange(
92
5.85k
                   std::min(kEigenIndexOne, rows - 1), rows - 1),
93
5.85k
               c = stream->ConsumeIntegralInRange(
94
5.85k
                   std::min(kEigenIndexOne, cols - 1), cols - 1);
95
96
5.85k
  m1.coeffRef(r, c) = x;
97
5.85k
  m1(r, c) = x;
98
5.85k
  v1.coeffRef(r) = x;
99
5.85k
  v1(r) = x;
100
5.85k
  v1[r] = x;
101
102
5.85k
  Eigen::Index r1 = stream->ConsumeIntegralInRange(
103
5.85k
      static_cast<Eigen::Index>(0),
104
5.85k
      std::min(static_cast<Eigen::Index>(127), rows - 1));
105
5.85k
  x = v1(static_cast<char>(r1));
106
5.85k
  x = v1(static_cast<signed char>(r1));
107
5.85k
  x = v1(static_cast<unsigned char>(r1));
108
5.85k
  x = v1(static_cast<signed short>(r1));
109
5.85k
  x = v1(static_cast<unsigned short>(r1));
110
5.85k
  x = v1(static_cast<signed int>(r1));
111
5.85k
  x = v1(static_cast<unsigned int>(r1));
112
5.85k
  x = v1(static_cast<signed long>(r1));
113
5.85k
  x = v1(static_cast<unsigned long>(r1));
114
5.85k
  x = v1(static_cast<long long int>(r1));
115
5.85k
  x = v1(static_cast<unsigned long long int>(r1));
116
117
  // now test copying a row-vector into a (column-)vector and conversely.
118
5.85k
  square.col(r) = square.row(r).eval();
119
5.85k
  Eigen::Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> rv(rows);
120
5.85k
  Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
121
5.85k
  rv = square.row(r);
122
5.85k
  cv = square.col(r);
123
124
5.85k
  cv.transpose();
125
126
5.85k
  m3.real() = m1.real();
127
5.85k
  m1 = m2;
128
129
5.85k
  sm2.setZero();
130
40.7k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
131
132
5.85k
  sm2.setZero();
133
40.7k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
134
135
5.85k
  sm2.setZero();
136
40.7k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
137
138
5.85k
  sm2.setZero();
139
40.7k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
140
5.85k
}
basicstuff_fuzzer.cc:void (anonymous namespace)::basicStuff<Eigen::Matrix<std::__1::complex<float>, -1, -1, 0, -1, -1> >(Eigen::Matrix<std::__1::complex<float>, -1, -1, 0, -1, -1> const&, FuzzedDataProvider*)
Line
Count
Source
68
1.46k
void basicStuff(const MatrixType& m, FuzzedDataProvider* stream) {
69
1.46k
  typedef typename MatrixType::Scalar Scalar;
70
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
71
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
72
1.46k
                        MatrixType::RowsAtCompileTime>
73
1.46k
      SquareMatrixType;
74
75
1.46k
  Eigen::Index rows = m.rows();
76
1.46k
  Eigen::Index cols = m.cols();
77
78
1.46k
  MatrixType m1 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
79
1.46k
             m2 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
80
1.46k
             m3(rows, cols), mzero = MatrixType::Zero(rows, cols),
81
1.46k
             square = GenerateTestMatrix<
82
1.46k
                 Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
83
1.46k
                               MatrixType::RowsAtCompileTime>>(rows, rows,
84
1.46k
                                                               stream);
85
1.46k
  VectorType v1 = GenerateTestMatrix<VectorType>(rows, 1, stream),
86
1.46k
             vzero = VectorType::Zero(rows);
87
1.46k
  SquareMatrixType sm1 = SquareMatrixType::Random(rows, rows), sm2(rows, rows);
88
89
1.46k
  Scalar x = ConsumeValue<typename MatrixType::Scalar>(stream);
90
91
1.46k
  Eigen::Index r = stream->ConsumeIntegralInRange(
92
1.46k
                   std::min(kEigenIndexOne, rows - 1), rows - 1),
93
1.46k
               c = stream->ConsumeIntegralInRange(
94
1.46k
                   std::min(kEigenIndexOne, cols - 1), cols - 1);
95
96
1.46k
  m1.coeffRef(r, c) = x;
97
1.46k
  m1(r, c) = x;
98
1.46k
  v1.coeffRef(r) = x;
99
1.46k
  v1(r) = x;
100
1.46k
  v1[r] = x;
101
102
1.46k
  Eigen::Index r1 = stream->ConsumeIntegralInRange(
103
1.46k
      static_cast<Eigen::Index>(0),
104
1.46k
      std::min(static_cast<Eigen::Index>(127), rows - 1));
105
1.46k
  x = v1(static_cast<char>(r1));
106
1.46k
  x = v1(static_cast<signed char>(r1));
107
1.46k
  x = v1(static_cast<unsigned char>(r1));
108
1.46k
  x = v1(static_cast<signed short>(r1));
109
1.46k
  x = v1(static_cast<unsigned short>(r1));
110
1.46k
  x = v1(static_cast<signed int>(r1));
111
1.46k
  x = v1(static_cast<unsigned int>(r1));
112
1.46k
  x = v1(static_cast<signed long>(r1));
113
1.46k
  x = v1(static_cast<unsigned long>(r1));
114
1.46k
  x = v1(static_cast<long long int>(r1));
115
1.46k
  x = v1(static_cast<unsigned long long int>(r1));
116
117
  // now test copying a row-vector into a (column-)vector and conversely.
118
1.46k
  square.col(r) = square.row(r).eval();
119
1.46k
  Eigen::Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> rv(rows);
120
1.46k
  Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
121
1.46k
  rv = square.row(r);
122
1.46k
  cv = square.col(r);
123
124
1.46k
  cv.transpose();
125
126
1.46k
  m3.real() = m1.real();
127
1.46k
  m1 = m2;
128
129
1.46k
  sm2.setZero();
130
7.79k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
131
132
1.46k
  sm2.setZero();
133
7.79k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
134
135
1.46k
  sm2.setZero();
136
7.79k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
137
138
1.46k
  sm2.setZero();
139
7.79k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
140
1.46k
}
basicstuff_fuzzer.cc:void (anonymous namespace)::basicStuff<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::Matrix<int, -1, -1, 0, -1, -1> const&, FuzzedDataProvider*)
Line
Count
Source
68
1.46k
void basicStuff(const MatrixType& m, FuzzedDataProvider* stream) {
69
1.46k
  typedef typename MatrixType::Scalar Scalar;
70
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
71
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
72
1.46k
                        MatrixType::RowsAtCompileTime>
73
1.46k
      SquareMatrixType;
74
75
1.46k
  Eigen::Index rows = m.rows();
76
1.46k
  Eigen::Index cols = m.cols();
77
78
1.46k
  MatrixType m1 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
79
1.46k
             m2 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
80
1.46k
             m3(rows, cols), mzero = MatrixType::Zero(rows, cols),
81
1.46k
             square = GenerateTestMatrix<
82
1.46k
                 Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
83
1.46k
                               MatrixType::RowsAtCompileTime>>(rows, rows,
84
1.46k
                                                               stream);
85
1.46k
  VectorType v1 = GenerateTestMatrix<VectorType>(rows, 1, stream),
86
1.46k
             vzero = VectorType::Zero(rows);
87
1.46k
  SquareMatrixType sm1 = SquareMatrixType::Random(rows, rows), sm2(rows, rows);
88
89
1.46k
  Scalar x = ConsumeValue<typename MatrixType::Scalar>(stream);
90
91
1.46k
  Eigen::Index r = stream->ConsumeIntegralInRange(
92
1.46k
                   std::min(kEigenIndexOne, rows - 1), rows - 1),
93
1.46k
               c = stream->ConsumeIntegralInRange(
94
1.46k
                   std::min(kEigenIndexOne, cols - 1), cols - 1);
95
96
1.46k
  m1.coeffRef(r, c) = x;
97
1.46k
  m1(r, c) = x;
98
1.46k
  v1.coeffRef(r) = x;
99
1.46k
  v1(r) = x;
100
1.46k
  v1[r] = x;
101
102
1.46k
  Eigen::Index r1 = stream->ConsumeIntegralInRange(
103
1.46k
      static_cast<Eigen::Index>(0),
104
1.46k
      std::min(static_cast<Eigen::Index>(127), rows - 1));
105
1.46k
  x = v1(static_cast<char>(r1));
106
1.46k
  x = v1(static_cast<signed char>(r1));
107
1.46k
  x = v1(static_cast<unsigned char>(r1));
108
1.46k
  x = v1(static_cast<signed short>(r1));
109
1.46k
  x = v1(static_cast<unsigned short>(r1));
110
1.46k
  x = v1(static_cast<signed int>(r1));
111
1.46k
  x = v1(static_cast<unsigned int>(r1));
112
1.46k
  x = v1(static_cast<signed long>(r1));
113
1.46k
  x = v1(static_cast<unsigned long>(r1));
114
1.46k
  x = v1(static_cast<long long int>(r1));
115
1.46k
  x = v1(static_cast<unsigned long long int>(r1));
116
117
  // now test copying a row-vector into a (column-)vector and conversely.
118
1.46k
  square.col(r) = square.row(r).eval();
119
1.46k
  Eigen::Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> rv(rows);
120
1.46k
  Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
121
1.46k
  rv = square.row(r);
122
1.46k
  cv = square.col(r);
123
124
1.46k
  cv.transpose();
125
126
1.46k
  m3.real() = m1.real();
127
1.46k
  m1 = m2;
128
129
1.46k
  sm2.setZero();
130
9.31k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
131
132
1.46k
  sm2.setZero();
133
9.31k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
134
135
1.46k
  sm2.setZero();
136
9.31k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
137
138
1.46k
  sm2.setZero();
139
9.31k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
140
1.46k
}
basicstuff_fuzzer.cc:void (anonymous namespace)::basicStuff<Eigen::Matrix<std::__1::complex<double>, -1, -1, 0, -1, -1> >(Eigen::Matrix<std::__1::complex<double>, -1, -1, 0, -1, -1> const&, FuzzedDataProvider*)
Line
Count
Source
68
1.46k
void basicStuff(const MatrixType& m, FuzzedDataProvider* stream) {
69
1.46k
  typedef typename MatrixType::Scalar Scalar;
70
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
71
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
72
1.46k
                        MatrixType::RowsAtCompileTime>
73
1.46k
      SquareMatrixType;
74
75
1.46k
  Eigen::Index rows = m.rows();
76
1.46k
  Eigen::Index cols = m.cols();
77
78
1.46k
  MatrixType m1 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
79
1.46k
             m2 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
80
1.46k
             m3(rows, cols), mzero = MatrixType::Zero(rows, cols),
81
1.46k
             square = GenerateTestMatrix<
82
1.46k
                 Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
83
1.46k
                               MatrixType::RowsAtCompileTime>>(rows, rows,
84
1.46k
                                                               stream);
85
1.46k
  VectorType v1 = GenerateTestMatrix<VectorType>(rows, 1, stream),
86
1.46k
             vzero = VectorType::Zero(rows);
87
1.46k
  SquareMatrixType sm1 = SquareMatrixType::Random(rows, rows), sm2(rows, rows);
88
89
1.46k
  Scalar x = ConsumeValue<typename MatrixType::Scalar>(stream);
90
91
1.46k
  Eigen::Index r = stream->ConsumeIntegralInRange(
92
1.46k
                   std::min(kEigenIndexOne, rows - 1), rows - 1),
93
1.46k
               c = stream->ConsumeIntegralInRange(
94
1.46k
                   std::min(kEigenIndexOne, cols - 1), cols - 1);
95
96
1.46k
  m1.coeffRef(r, c) = x;
97
1.46k
  m1(r, c) = x;
98
1.46k
  v1.coeffRef(r) = x;
99
1.46k
  v1(r) = x;
100
1.46k
  v1[r] = x;
101
102
1.46k
  Eigen::Index r1 = stream->ConsumeIntegralInRange(
103
1.46k
      static_cast<Eigen::Index>(0),
104
1.46k
      std::min(static_cast<Eigen::Index>(127), rows - 1));
105
1.46k
  x = v1(static_cast<char>(r1));
106
1.46k
  x = v1(static_cast<signed char>(r1));
107
1.46k
  x = v1(static_cast<unsigned char>(r1));
108
1.46k
  x = v1(static_cast<signed short>(r1));
109
1.46k
  x = v1(static_cast<unsigned short>(r1));
110
1.46k
  x = v1(static_cast<signed int>(r1));
111
1.46k
  x = v1(static_cast<unsigned int>(r1));
112
1.46k
  x = v1(static_cast<signed long>(r1));
113
1.46k
  x = v1(static_cast<unsigned long>(r1));
114
1.46k
  x = v1(static_cast<long long int>(r1));
115
1.46k
  x = v1(static_cast<unsigned long long int>(r1));
116
117
  // now test copying a row-vector into a (column-)vector and conversely.
118
1.46k
  square.col(r) = square.row(r).eval();
119
1.46k
  Eigen::Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> rv(rows);
120
1.46k
  Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
121
1.46k
  rv = square.row(r);
122
1.46k
  cv = square.col(r);
123
124
1.46k
  cv.transpose();
125
126
1.46k
  m3.real() = m1.real();
127
1.46k
  m1 = m2;
128
129
1.46k
  sm2.setZero();
130
11.1k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
131
132
1.46k
  sm2.setZero();
133
11.1k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
134
135
1.46k
  sm2.setZero();
136
11.1k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
137
138
1.46k
  sm2.setZero();
139
11.1k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
140
1.46k
}
basicstuff_fuzzer.cc:void (anonymous namespace)::basicStuff<Eigen::Matrix<long double, -1, -1, 0, -1, -1> >(Eigen::Matrix<long double, -1, -1, 0, -1, -1> const&, FuzzedDataProvider*)
Line
Count
Source
68
1.46k
void basicStuff(const MatrixType& m, FuzzedDataProvider* stream) {
69
1.46k
  typedef typename MatrixType::Scalar Scalar;
70
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
71
1.46k
  typedef Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
72
1.46k
                        MatrixType::RowsAtCompileTime>
73
1.46k
      SquareMatrixType;
74
75
1.46k
  Eigen::Index rows = m.rows();
76
1.46k
  Eigen::Index cols = m.cols();
77
78
1.46k
  MatrixType m1 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
79
1.46k
             m2 = GenerateTestMatrix<MatrixType>(rows, cols, stream),
80
1.46k
             m3(rows, cols), mzero = MatrixType::Zero(rows, cols),
81
1.46k
             square = GenerateTestMatrix<
82
1.46k
                 Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime,
83
1.46k
                               MatrixType::RowsAtCompileTime>>(rows, rows,
84
1.46k
                                                               stream);
85
1.46k
  VectorType v1 = GenerateTestMatrix<VectorType>(rows, 1, stream),
86
1.46k
             vzero = VectorType::Zero(rows);
87
1.46k
  SquareMatrixType sm1 = SquareMatrixType::Random(rows, rows), sm2(rows, rows);
88
89
1.46k
  Scalar x = ConsumeValue<typename MatrixType::Scalar>(stream);
90
91
1.46k
  Eigen::Index r = stream->ConsumeIntegralInRange(
92
1.46k
                   std::min(kEigenIndexOne, rows - 1), rows - 1),
93
1.46k
               c = stream->ConsumeIntegralInRange(
94
1.46k
                   std::min(kEigenIndexOne, cols - 1), cols - 1);
95
96
1.46k
  m1.coeffRef(r, c) = x;
97
1.46k
  m1(r, c) = x;
98
1.46k
  v1.coeffRef(r) = x;
99
1.46k
  v1(r) = x;
100
1.46k
  v1[r] = x;
101
102
1.46k
  Eigen::Index r1 = stream->ConsumeIntegralInRange(
103
1.46k
      static_cast<Eigen::Index>(0),
104
1.46k
      std::min(static_cast<Eigen::Index>(127), rows - 1));
105
1.46k
  x = v1(static_cast<char>(r1));
106
1.46k
  x = v1(static_cast<signed char>(r1));
107
1.46k
  x = v1(static_cast<unsigned char>(r1));
108
1.46k
  x = v1(static_cast<signed short>(r1));
109
1.46k
  x = v1(static_cast<unsigned short>(r1));
110
1.46k
  x = v1(static_cast<signed int>(r1));
111
1.46k
  x = v1(static_cast<unsigned int>(r1));
112
1.46k
  x = v1(static_cast<signed long>(r1));
113
1.46k
  x = v1(static_cast<unsigned long>(r1));
114
1.46k
  x = v1(static_cast<long long int>(r1));
115
1.46k
  x = v1(static_cast<unsigned long long int>(r1));
116
117
  // now test copying a row-vector into a (column-)vector and conversely.
118
1.46k
  square.col(r) = square.row(r).eval();
119
1.46k
  Eigen::Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> rv(rows);
120
1.46k
  Eigen::Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
121
1.46k
  rv = square.row(r);
122
1.46k
  cv = square.col(r);
123
124
1.46k
  cv.transpose();
125
126
1.46k
  m3.real() = m1.real();
127
1.46k
  m1 = m2;
128
129
1.46k
  sm2.setZero();
130
12.4k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
131
132
1.46k
  sm2.setZero();
133
12.4k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
134
135
1.46k
  sm2.setZero();
136
12.4k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
137
138
1.46k
  sm2.setZero();
139
12.4k
  for (Eigen::Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
140
1.46k
}
141
142
template <typename MatrixType>
143
2.92k
void basicStuffComplex(const MatrixType& m, FuzzedDataProvider* stream) {
144
2.92k
  typedef typename MatrixType::Scalar Scalar;
145
2.92k
  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
146
2.92k
  typedef Eigen::Matrix<RealScalar, MatrixType::RowsAtCompileTime,
147
2.92k
                        MatrixType::ColsAtCompileTime>
148
2.92k
      RealMatrixType;
149
150
2.92k
  Eigen::Index rows = m.rows();
151
2.92k
  Eigen::Index cols = m.cols();
152
153
2.92k
  RealMatrixType rm1 = GenerateTestMatrix<RealMatrixType>(rows, cols, stream),
154
2.92k
                 rm2 = GenerateTestMatrix<RealMatrixType>(rows, cols, stream);
155
2.92k
  MatrixType cm(rows, cols);
156
2.92k
  cm.real() = rm1;
157
2.92k
  cm.imag() = rm2;
158
2.92k
  rm1.setZero();
159
2.92k
  rm2.setZero();
160
2.92k
  rm1 = cm.real();
161
2.92k
  rm2 = cm.imag();
162
2.92k
  cm.real().setZero();
163
2.92k
}
basicstuff_fuzzer.cc:void (anonymous namespace)::basicStuffComplex<Eigen::Matrix<std::__1::complex<float>, -1, -1, 0, -1, -1> >(Eigen::Matrix<std::__1::complex<float>, -1, -1, 0, -1, -1> const&, FuzzedDataProvider*)
Line
Count
Source
143
1.46k
void basicStuffComplex(const MatrixType& m, FuzzedDataProvider* stream) {
144
1.46k
  typedef typename MatrixType::Scalar Scalar;
145
1.46k
  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
146
1.46k
  typedef Eigen::Matrix<RealScalar, MatrixType::RowsAtCompileTime,
147
1.46k
                        MatrixType::ColsAtCompileTime>
148
1.46k
      RealMatrixType;
149
150
1.46k
  Eigen::Index rows = m.rows();
151
1.46k
  Eigen::Index cols = m.cols();
152
153
1.46k
  RealMatrixType rm1 = GenerateTestMatrix<RealMatrixType>(rows, cols, stream),
154
1.46k
                 rm2 = GenerateTestMatrix<RealMatrixType>(rows, cols, stream);
155
1.46k
  MatrixType cm(rows, cols);
156
1.46k
  cm.real() = rm1;
157
1.46k
  cm.imag() = rm2;
158
1.46k
  rm1.setZero();
159
1.46k
  rm2.setZero();
160
1.46k
  rm1 = cm.real();
161
1.46k
  rm2 = cm.imag();
162
1.46k
  cm.real().setZero();
163
1.46k
}
basicstuff_fuzzer.cc:void (anonymous namespace)::basicStuffComplex<Eigen::Matrix<std::__1::complex<double>, -1, -1, 0, -1, -1> >(Eigen::Matrix<std::__1::complex<double>, -1, -1, 0, -1, -1> const&, FuzzedDataProvider*)
Line
Count
Source
143
1.46k
void basicStuffComplex(const MatrixType& m, FuzzedDataProvider* stream) {
144
1.46k
  typedef typename MatrixType::Scalar Scalar;
145
1.46k
  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
146
1.46k
  typedef Eigen::Matrix<RealScalar, MatrixType::RowsAtCompileTime,
147
1.46k
                        MatrixType::ColsAtCompileTime>
148
1.46k
      RealMatrixType;
149
150
1.46k
  Eigen::Index rows = m.rows();
151
1.46k
  Eigen::Index cols = m.cols();
152
153
1.46k
  RealMatrixType rm1 = GenerateTestMatrix<RealMatrixType>(rows, cols, stream),
154
1.46k
                 rm2 = GenerateTestMatrix<RealMatrixType>(rows, cols, stream);
155
1.46k
  MatrixType cm(rows, cols);
156
1.46k
  cm.real() = rm1;
157
1.46k
  cm.imag() = rm2;
158
1.46k
  rm1.setZero();
159
1.46k
  rm2.setZero();
160
1.46k
  rm1 = cm.real();
161
1.46k
  rm2 = cm.imag();
162
1.46k
  cm.real().setZero();
163
1.46k
}
164
165
}  // namespace
166
167
1.46k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
168
1.46k
  FuzzedDataProvider stream(data, size);
169
170
1.46k
  basicStuff(
171
1.46k
      Eigen::MatrixXcf(
172
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize),
173
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize)),
174
1.46k
      &stream);
175
1.46k
  basicStuff(
176
1.46k
      Eigen::MatrixXi(
177
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize),
178
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize)),
179
1.46k
      &stream);
180
1.46k
  basicStuff(
181
1.46k
      Eigen::MatrixXcd(
182
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize),
183
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize)),
184
1.46k
      &stream);
185
1.46k
  basicStuff(
186
1.46k
      Eigen::Matrix<long double, Eigen::Dynamic, Eigen::Dynamic>(
187
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize),
188
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize)),
189
1.46k
      &stream);
190
1.46k
  basicStuffComplex(
191
1.46k
      Eigen::MatrixXcf(
192
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize),
193
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize)),
194
1.46k
      &stream);
195
1.46k
  basicStuffComplex(
196
1.46k
      Eigen::MatrixXcd(
197
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize),
198
1.46k
          stream.ConsumeIntegralInRange(kEigenIndexOne, kEigenTestMaxSize)),
199
1.46k
      &stream);
200
201
1.46k
  return 0;
202
1.46k
}