Skip to content

Commit e07c9f5

Browse files
kunitokikunitoki
committed
Fix issue in tests
1 parent be4af96 commit e07c9f5

2 files changed

Lines changed: 87 additions & 87 deletions

File tree

‎tests/yup_dsp/yup_AnalogFilters.cpp‎

Lines changed: 51 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -27,22 +27,22 @@ using namespace yup;
2727

2828
namespace
2929
{
30-
constexpr double sampleRate = 44100.0;
31-
constexpr int blockSize = 128;
30+
constexpr double analogSampleRate = 44100.0;
31+
constexpr int analogBlockSize = 128;
3232

3333
template <typename SampleType>
34-
std::vector<SampleType> makeInput()
34+
std::vector<SampleType> makeAnalogInput()
3535
{
36-
std::vector<SampleType> input (blockSize);
36+
std::vector<SampleType> input (analogBlockSize);
3737

38-
for (int i = 0; i < blockSize; ++i)
38+
for (int i = 0; i < analogBlockSize; ++i)
3939
input[static_cast<std::size_t> (i)] = static_cast<SampleType> ((i % 17) / 17.0 - 0.5);
4040

4141
return input;
4242
}
4343

4444
template <typename SampleType>
45-
void expectFiniteBuffer (const std::vector<SampleType>& buffer)
45+
void expectFiniteAnalogBuffer (const std::vector<SampleType>& buffer)
4646
{
4747
for (auto sample : buffer)
4848
EXPECT_TRUE (std::isfinite (sample));
@@ -53,9 +53,9 @@ void expectFiniteBuffer (const std::vector<SampleType>& buffer)
5353

5454
TEST (AnalogFilterDesignerTests, DesignsFiniteTwoPoleCoefficients)
5555
{
56-
const auto lowpass = AnalogFilterDesigner<double>::designTwoPole (FilterMode::lowpass, 1000.0, sampleRate, 0.5);
57-
const auto bandpass = AnalogFilterDesigner<double>::designTwoPole (FilterMode::bandpassCpg, 1000.0, sampleRate, 0.5);
58-
const auto peak = AnalogFilterDesigner<double>::designTwoPole (FilterMode::peak, 1000.0, sampleRate, 0.5);
56+
const auto lowpass = AnalogFilterDesigner<double>::designTwoPole (FilterMode::lowpass, 1000.0, analogSampleRate, 0.5);
57+
const auto bandpass = AnalogFilterDesigner<double>::designTwoPole (FilterMode::bandpassCpg, 1000.0, analogSampleRate, 0.5);
58+
const auto peak = AnalogFilterDesigner<double>::designTwoPole (FilterMode::peak, 1000.0, analogSampleRate, 0.5);
5959

6060
EXPECT_TRUE (std::isfinite (lowpass.g));
6161
EXPECT_TRUE (std::isfinite (lowpass.h));
@@ -65,9 +65,9 @@ TEST (AnalogFilterDesignerTests, DesignsFiniteTwoPoleCoefficients)
6565

6666
TEST (AnalogFilterDesignerTests, DesignsFiniteLadderCoefficients)
6767
{
68-
const auto korg = AnalogFilterDesigner<double>::designKorg35 (FilterMode::lowpass, 1200.0, sampleRate, 0.7, 0.25);
69-
const auto moog = AnalogFilterDesigner<double>::designMoogLadder (AnalogMoogLadderMode::lowpass24, 1200.0, sampleRate, 0.7, 0.25);
70-
const auto diode = AnalogFilterDesigner<double>::designRolandDiode (1200.0, sampleRate, 0.7, 0.25);
68+
const auto korg = AnalogFilterDesigner<double>::designKorg35 (FilterMode::lowpass, 1200.0, analogSampleRate, 0.7, 0.25);
69+
const auto moog = AnalogFilterDesigner<double>::designMoogLadder (AnalogMoogLadderMode::lowpass24, 1200.0, analogSampleRate, 0.7, 0.25);
70+
const auto diode = AnalogFilterDesigner<double>::designRolandDiode (1200.0, analogSampleRate, 0.7, 0.25);
7171

7272
EXPECT_TRUE (std::isfinite (korg.alpha0));
7373
EXPECT_TRUE (std::isfinite (korg.feedback));
@@ -79,7 +79,7 @@ TEST (AnalogFilterDesignerTests, DesignsFiniteLadderCoefficients)
7979

8080
TEST (AnalogFilterDesignerTests, DesignsVowelFormants)
8181
{
82-
const auto vowel = AnalogFilterDesigner<double>::designVowel (0.35, sampleRate, 0.8);
82+
const auto vowel = AnalogFilterDesigner<double>::designVowel (0.35, analogSampleRate, 0.8);
8383

8484
EXPECT_TRUE (std::isfinite (vowel.gainCompensation));
8585

@@ -96,93 +96,93 @@ TEST (AnalogFilterDesignerTests, DesignsVowelFormants)
9696
TEST (AnalogFilterTests, TwoPoleProcessesFiniteOutput)
9797
{
9898
AnalogTwoPoleFilter<float> filter;
99-
filter.prepare (sampleRate, blockSize);
100-
filter.setParameters (FilterMode::bandpassCpg, 1000.0f, 0.75f, 0.2f, sampleRate);
99+
filter.prepare (analogSampleRate, analogBlockSize);
100+
filter.setParameters (FilterMode::bandpassCpg, 1000.0f, 0.75f, 0.2f, analogSampleRate);
101101

102-
const auto input = makeInput<float>();
103-
std::vector<float> output (blockSize);
102+
const auto input = makeAnalogInput<float>();
103+
std::vector<float> output (analogBlockSize);
104104

105-
filter.processBlock (input.data(), output.data(), blockSize);
105+
filter.processBlock (input.data(), output.data(), analogBlockSize);
106106

107-
expectFiniteBuffer (output);
107+
expectFiniteAnalogBuffer (output);
108108
}
109109

110110
TEST (AnalogFilterTests, VowelProcessesFiniteOutput)
111111
{
112112
AnalogVowelFilter<float> filter;
113-
filter.prepare (sampleRate, blockSize);
114-
filter.setParameters (0.5f, 0.75f, 0.2f, sampleRate);
113+
filter.prepare (analogSampleRate, analogBlockSize);
114+
filter.setParameters (0.5f, 0.75f, 0.2f, analogSampleRate);
115115

116-
const auto input = makeInput<float>();
117-
std::vector<float> output (blockSize);
116+
const auto input = makeAnalogInput<float>();
117+
std::vector<float> output (analogBlockSize);
118118

119-
filter.processBlock (input.data(), output.data(), blockSize);
119+
filter.processBlock (input.data(), output.data(), analogBlockSize);
120120

121-
expectFiniteBuffer (output);
121+
expectFiniteAnalogBuffer (output);
122122
}
123123

124124
TEST (AnalogFilterTests, Korg35ProcessesAllModes)
125125
{
126-
const auto input = makeInput<float>();
126+
const auto input = makeAnalogInput<float>();
127127

128128
for (auto mode : { FilterMode::lowpass, FilterMode::bandpassCsg, FilterMode::highpass })
129129
{
130130
AnalogKorg35Filter<float> filter;
131-
filter.prepare (sampleRate, blockSize);
132-
filter.setParameters (mode, 1000.0f, 0.6f, 0.2f, sampleRate);
131+
filter.prepare (analogSampleRate, analogBlockSize);
132+
filter.setParameters (mode, 1000.0f, 0.6f, 0.2f, analogSampleRate);
133133

134-
std::vector<float> output (blockSize);
135-
filter.processBlock (input.data(), output.data(), blockSize);
134+
std::vector<float> output (analogBlockSize);
135+
filter.processBlock (input.data(), output.data(), analogBlockSize);
136136

137-
expectFiniteBuffer (output);
137+
expectFiniteAnalogBuffer (output);
138138
}
139139
}
140140

141141
TEST (AnalogFilterTests, MoogLadderProcessesRepresentativeModes)
142142
{
143-
const auto input = makeInput<float>();
143+
const auto input = makeAnalogInput<float>();
144144

145145
for (auto mode : { AnalogMoogLadderMode::lowpass24, AnalogMoogLadderMode::highpass12, AnalogMoogLadderMode::bandpass6 })
146146
{
147147
AnalogMoogLadderFilter<float> filter;
148-
filter.prepare (sampleRate, blockSize);
149-
filter.setParameters (mode, 1000.0f, 0.6f, 0.2f, sampleRate);
148+
filter.prepare (analogSampleRate, analogBlockSize);
149+
filter.setParameters (mode, 1000.0f, 0.6f, 0.2f, analogSampleRate);
150150

151-
std::vector<float> output (blockSize);
152-
filter.processBlock (input.data(), output.data(), blockSize);
151+
std::vector<float> output (analogBlockSize);
152+
filter.processBlock (input.data(), output.data(), analogBlockSize);
153153

154-
expectFiniteBuffer (output);
154+
expectFiniteAnalogBuffer (output);
155155
}
156156
}
157157

158158
TEST (AnalogFilterTests, RolandDiodeProcessesFiniteOutput)
159159
{
160160
AnalogRolandDiodeFilter<float> filter;
161-
filter.prepare (sampleRate, blockSize);
162-
filter.setParameters (1000.0f, 0.6f, 0.2f, sampleRate);
161+
filter.prepare (analogSampleRate, analogBlockSize);
162+
filter.setParameters (1000.0f, 0.6f, 0.2f, analogSampleRate);
163163

164-
const auto input = makeInput<float>();
165-
std::vector<float> output (blockSize);
164+
const auto input = makeAnalogInput<float>();
165+
std::vector<float> output (analogBlockSize);
166166

167-
filter.processBlock (input.data(), output.data(), blockSize);
167+
filter.processBlock (input.data(), output.data(), analogBlockSize);
168168

169-
expectFiniteBuffer (output);
169+
expectFiniteAnalogBuffer (output);
170170
}
171171

172172
TEST (AnalogFilterTests, ResetRestoresDeterministicState)
173173
{
174174
AnalogMoogLadderFilter<float> filter;
175-
filter.prepare (sampleRate, blockSize);
176-
filter.setParameters (AnalogMoogLadderMode::lowpass24, 1000.0f, 0.5f, 0.1f, sampleRate);
175+
filter.prepare (analogSampleRate, analogBlockSize);
176+
filter.setParameters (AnalogMoogLadderMode::lowpass24, 1000.0f, 0.5f, 0.1f, analogSampleRate);
177177

178-
const auto input = makeInput<float>();
179-
std::vector<float> firstOutput (blockSize);
180-
std::vector<float> secondOutput (blockSize);
178+
const auto input = makeAnalogInput<float>();
179+
std::vector<float> firstOutput (analogBlockSize);
180+
std::vector<float> secondOutput (analogBlockSize);
181181

182-
filter.processBlock (input.data(), firstOutput.data(), blockSize);
182+
filter.processBlock (input.data(), firstOutput.data(), analogBlockSize);
183183
filter.reset();
184-
filter.processBlock (input.data(), secondOutput.data(), blockSize);
184+
filter.processBlock (input.data(), secondOutput.data(), analogBlockSize);
185185

186-
for (int i = 0; i < blockSize; ++i)
186+
for (int i = 0; i < analogBlockSize; ++i)
187187
EXPECT_FLOAT_EQ (firstOutput[static_cast<std::size_t> (i)], secondOutput[static_cast<std::size_t> (i)]);
188188
}

‎tests/yup_dsp/yup_CombFilter.cpp‎

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -27,11 +27,11 @@ using namespace yup;
2727

2828
namespace
2929
{
30-
constexpr double sampleRate = 48000.0;
31-
constexpr int blockSize = 128;
30+
constexpr double combSampleRate = 48000.0;
31+
constexpr int combBlockSize = 128;
3232

3333
template <typename SampleType>
34-
void expectFiniteBuffer (const std::vector<SampleType>& buffer)
34+
void expectFiniteCombBuffer (const std::vector<SampleType>& buffer)
3535
{
3636
for (auto sample : buffer)
3737
EXPECT_TRUE (std::isfinite (sample));
@@ -44,80 +44,80 @@ TEST (CombFilterTests, DefaultConstructorInitializes)
4444
{
4545
CombFilter<float> filter;
4646

47-
EXPECT_NO_THROW (filter.prepare (sampleRate, blockSize));
47+
EXPECT_NO_THROW (filter.prepare (combSampleRate, combBlockSize));
4848
EXPECT_GT (filter.getFrequency(), 0.0f);
4949
EXPECT_GE (filter.getDelayInSamples(), 1.0f);
5050
}
5151

5252
TEST (CombFilterTests, ProducesExpectedFeedForwardDelayTap)
5353
{
5454
CombFilter<float> filter;
55-
filter.prepare (sampleRate, blockSize);
56-
filter.setParameters (static_cast<float> (sampleRate / 8.0), 0.0f, 0.0f, sampleRate);
55+
filter.prepare (combSampleRate, combBlockSize);
56+
filter.setParameters (static_cast<float> (combSampleRate / 8.0), 0.0f, 0.0f, combSampleRate);
5757
filter.reset();
5858

59-
std::vector<float> input (blockSize, 0.0f);
60-
std::vector<float> output (blockSize, 0.0f);
59+
std::vector<float> input (combBlockSize, 0.0f);
60+
std::vector<float> output (combBlockSize, 0.0f);
6161
input[0] = 1.0f;
6262

63-
filter.processBlock (input.data(), output.data(), blockSize);
63+
filter.processBlock (input.data(), output.data(), combBlockSize);
6464

6565
EXPECT_FLOAT_EQ (output[0], 1.0f);
6666
EXPECT_NEAR (output[8], 0.5f, 1e-5f);
67-
expectFiniteBuffer (output);
67+
expectFiniteCombBuffer (output);
6868
}
6969

7070
TEST (CombFilterTests, FeedbackAndSaturationRemainFinite)
7171
{
7272
CombFilter<float> filter;
73-
filter.prepare (sampleRate, blockSize);
74-
filter.setParameters (440.0f, 1.0f, 1.0f, sampleRate);
73+
filter.prepare (combSampleRate, combBlockSize);
74+
filter.setParameters (440.0f, 1.0f, 1.0f, combSampleRate);
7575
filter.setSignalRange (2.0f);
7676

77-
std::vector<float> input (blockSize, 0.25f);
78-
std::vector<float> output (blockSize, 0.0f);
77+
std::vector<float> input (combBlockSize, 0.25f);
78+
std::vector<float> output (combBlockSize, 0.0f);
7979

80-
filter.processBlock (input.data(), output.data(), blockSize);
80+
filter.processBlock (input.data(), output.data(), combBlockSize);
8181

82-
expectFiniteBuffer (output);
82+
expectFiniteCombBuffer (output);
8383
}
8484

8585
TEST (CombFilterTests, SetParametersFromNoteUpdatesDelay)
8686
{
8787
CombFilter<double> filter;
88-
filter.prepare (sampleRate, blockSize);
89-
filter.setParametersFromNote (69.0, 0.5, 0.0, sampleRate);
88+
filter.prepare (combSampleRate, combBlockSize);
89+
filter.setParametersFromNote (69.0, 0.5, 0.0, combSampleRate);
9090

9191
EXPECT_NEAR (filter.getFrequency(), 440.0, 1e-9);
92-
EXPECT_NEAR (filter.getDelayInSamples(), sampleRate / 440.0, 1e-9);
92+
EXPECT_NEAR (filter.getDelayInSamples(), combSampleRate / 440.0, 1e-9);
9393
}
9494

9595
TEST (CombFilterTests, ResetRestoresDeterministicState)
9696
{
9797
CombFilter<float> filter;
98-
filter.prepare (sampleRate, blockSize);
99-
filter.setParameters (660.0f, 0.5f, 0.2f, sampleRate);
98+
filter.prepare (combSampleRate, combBlockSize);
99+
filter.setParameters (660.0f, 0.5f, 0.2f, combSampleRate);
100100

101-
std::vector<float> input (blockSize, 0.0f);
102-
std::vector<float> firstOutput (blockSize, 0.0f);
103-
std::vector<float> secondOutput (blockSize, 0.0f);
101+
std::vector<float> input (combBlockSize, 0.0f);
102+
std::vector<float> firstOutput (combBlockSize, 0.0f);
103+
std::vector<float> secondOutput (combBlockSize, 0.0f);
104104

105-
for (int i = 0; i < blockSize; ++i)
105+
for (int i = 0; i < combBlockSize; ++i)
106106
input[static_cast<std::size_t> (i)] = (i % 5 == 0) ? 0.5f : -0.125f;
107107

108-
filter.processBlock (input.data(), firstOutput.data(), blockSize);
108+
filter.processBlock (input.data(), firstOutput.data(), combBlockSize);
109109
filter.reset();
110-
filter.processBlock (input.data(), secondOutput.data(), blockSize);
110+
filter.processBlock (input.data(), secondOutput.data(), combBlockSize);
111111

112-
for (int i = 0; i < blockSize; ++i)
112+
for (int i = 0; i < combBlockSize; ++i)
113113
EXPECT_FLOAT_EQ (firstOutput[static_cast<std::size_t> (i)], secondOutput[static_cast<std::size_t> (i)]);
114114
}
115115

116116
TEST (CombFilterTests, ComplexResponseIsFinite)
117117
{
118118
CombFilter<double> filter;
119-
filter.prepare (sampleRate, blockSize);
120-
filter.setParameters (440.0, 0.7, 0.3, sampleRate);
119+
filter.prepare (combSampleRate, combBlockSize);
120+
filter.setParameters (440.0, 0.7, 0.3, combSampleRate);
121121

122122
const auto response = filter.getComplexResponse (1000.0);
123123

@@ -128,18 +128,18 @@ TEST (CombFilterTests, ComplexResponseIsFinite)
128128
TEST (CombFilterTests, ComplexResponseMatchesIntegerDelayFeedForwardComb)
129129
{
130130
CombFilter<double> filter;
131-
filter.prepare (sampleRate, blockSize);
132-
filter.setParameters (sampleRate / 8.0, 0.0, 0.0, sampleRate);
131+
filter.prepare (combSampleRate, combBlockSize);
132+
filter.setParameters (combSampleRate / 8.0, 0.0, 0.0, combSampleRate);
133133

134134
EXPECT_NEAR (std::abs (filter.getComplexResponse (0.0)), 1.5, 1e-9);
135-
EXPECT_NEAR (std::abs (filter.getComplexResponse (sampleRate / 16.0)), 0.5, 1e-9);
135+
EXPECT_NEAR (std::abs (filter.getComplexResponse (combSampleRate / 16.0)), 0.5, 1e-9);
136136
}
137137

138138
TEST (CombFilterTests, ComplexResponseIncludesFeedbackResonance)
139139
{
140140
CombFilter<double> filter;
141-
filter.prepare (sampleRate, blockSize);
142-
filter.setParameters (sampleRate / 8.0, 0.81, 0.0, sampleRate);
141+
filter.prepare (combSampleRate, combBlockSize);
142+
filter.setParameters (combSampleRate / 8.0, 0.81, 0.0, combSampleRate);
143143

144-
EXPECT_NEAR (std::abs (filter.getComplexResponse (sampleRate / 8.0)), 6.0, 1e-9);
144+
EXPECT_NEAR (std::abs (filter.getComplexResponse (combSampleRate / 8.0)), 6.0, 1e-9);
145145
}

0 commit comments

Comments
 (0)