A Discrete-Event Network Simulator
API
spectrum-value-test.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2009 CTTC
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation;
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16  *
17  * Author: Nicola Baldo <nbaldo@cttc.es>
18  */
19 
20 #include "spectrum-test.h"
21 
22 #include <ns3/log.h>
23 #include <ns3/object.h>
24 #include <ns3/spectrum-converter.h>
25 #include <ns3/spectrum-value.h>
26 #include <ns3/test.h>
27 
28 #include <cmath>
29 #include <iostream>
30 
31 using namespace ns3;
32 
33 // NS_LOG_COMPONENT_DEFINE ("SpectrumValueTest");
34 
35 #define TOLERANCE 1e-6
36 
42 class SpectrumValueTestCase : public TestCase
43 {
44  public:
51  SpectrumValueTestCase(SpectrumValue a, SpectrumValue b, std::string name);
52  ~SpectrumValueTestCase() override;
53  void DoRun() override;
54 
55  private:
62  bool MoreOrLessEqual(SpectrumValue x, SpectrumValue y);
63 
64  SpectrumValue m_a;
65  SpectrumValue m_b;
66 };
67 
68 SpectrumValueTestCase::SpectrumValueTestCase(SpectrumValue a, SpectrumValue b, std::string name)
69  : TestCase(name),
70  m_a(a),
71  m_b(b)
72 {
73 }
74 
75 SpectrumValueTestCase::~SpectrumValueTestCase()
76 {
77 }
78 
79 bool
80 SpectrumValueTestCase::MoreOrLessEqual(SpectrumValue x, SpectrumValue y)
81 {
82  SpectrumValue z = x - y;
83  return (Norm(z) < TOLERANCE);
84 }
85 
86 void
87 SpectrumValueTestCase::DoRun()
88 {
89  NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL(*m_a.GetSpectrumModel(),
90  *m_b.GetSpectrumModel(),
91  TOLERANCE,
92  "");
93  NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL(m_a, m_b, TOLERANCE, "");
94 }
95 
101 class SpectrumValueTestSuite : public TestSuite
102 {
103  public:
104  SpectrumValueTestSuite();
105 };
106 
107 SpectrumValueTestSuite::SpectrumValueTestSuite()
108  : TestSuite("spectrum-value", UNIT)
109 {
110  // NS_LOG_INFO("creating SpectrumValueTestSuite");
111 
112  std::vector<double> freqs;
113 
114  for (int i = 1; i <= 5; i++)
115  {
116  freqs.push_back(i);
117  }
118 
119  Ptr<SpectrumModel> f = Create<SpectrumModel>(freqs);
120 
121  SpectrumValue v1(f);
122  SpectrumValue v2(f);
123  SpectrumValue v3(f);
124  SpectrumValue v4(f);
125  SpectrumValue v5(f);
126  SpectrumValue v6(f);
127  SpectrumValue v7(f);
128  SpectrumValue v8(f);
129  SpectrumValue v9(f);
130  SpectrumValue v10(f);
131 
132  double doubleValue;
133 
134  doubleValue = 1.12345600000000;
135 
136  v1[0] = 0.700539792840;
137  v1[1] = -0.554277600423;
138  v1[2] = 0.750309319469;
139  v1[3] = -0.892299213192;
140  v1[4] = 0.987045234885;
141 
142  v2[0] = 0.870441628737;
143  v2[1] = 0.271419263880;
144  v2[2] = 0.451557288312;
145  v2[3] = 0.968992859395;
146  v2[4] = -0.929186654705;
147 
148  v3[0] = 1.570981421577;
149  v3[1] = -0.282858336543;
150  v3[2] = 1.201866607781;
151  v3[3] = 0.076693646203;
152  v3[4] = 0.057858580180;
153 
154  v4[0] = -0.169901835897;
155  v4[1] = -0.825696864302;
156  v4[2] = 0.298752031158;
157  v4[3] = -1.861292072588;
158  v4[4] = 1.916231889590;
159 
160  v5[0] = 0.609778998275;
161  v5[1] = -0.150441618292;
162  v5[2] = 0.338807641695;
163  v5[3] = -0.864631566028;
164  v5[4] = -0.917149259846;
165 
166  v6[0] = 0.804809615846;
167  v6[1] = -2.042145397125;
168  v6[2] = 1.661603829438;
169  v6[3] = -0.920852207053;
170  v6[4] = -1.062267984465;
171 
172  v7[0] = 1.823995792840;
173  v7[1] = 0.569178399577;
174  v7[2] = 1.873765319469;
175  v7[3] = 0.231156786808;
176  v7[4] = 2.110501234885;
177 
178  v8[0] = -0.422916207160;
179  v8[1] = -1.677733600423;
180  v8[2] = -0.373146680531;
181  v8[3] = -2.015755213192;
182  v8[4] = -0.136410765115;
183 
184  v9[0] = 0.787025633505;
185  v9[1] = -0.622706495860;
186  v9[2] = 0.842939506814;
187  v9[3] = -1.002458904856;
188  v9[4] = 1.108901891403;
189 
190  v10[0] = 0.623557836569;
191  v10[1] = -0.493368320987;
192  v10[2] = 0.667858215604;
193  v10[3] = -0.794244913190;
194  v10[4] = 0.878579343459;
195 
196  SpectrumValue tv3(f);
197  SpectrumValue tv4(f);
198  SpectrumValue tv5(f);
199  SpectrumValue tv6(f);
200 
201  tv3 = v1 + v2;
202  tv4 = v1 - v2;
203  tv5 = v1 * v2;
204  tv6 = v1 / v2;
205 
206  AddTestCase(new SpectrumValueTestCase(tv3, v3, "tv3 = v1 + v2"), TestCase::QUICK);
207  AddTestCase(new SpectrumValueTestCase(tv4, v4, "tv4 = v1 - v2"), TestCase::QUICK);
208  AddTestCase(new SpectrumValueTestCase(tv5, v5, "tv5 = v1 * v2"), TestCase::QUICK);
209  AddTestCase(new SpectrumValueTestCase(tv6, v6, "tv6 = v1 div v2"), TestCase::QUICK);
210 
211  // std::cerr << v6 << std::endl;
212  // std::cerr << tv6 << std::endl;
213 
214  tv3 = v1;
215  tv4 = v1;
216  tv5 = v1;
217  tv6 = v1;
218 
219  tv3 += v2;
220  tv4 -= v2;
221  tv5 *= v2;
222  tv6 /= v2;
223 
224  AddTestCase(new SpectrumValueTestCase(tv3, v3, "tv3 += v2"), TestCase::QUICK);
225  AddTestCase(new SpectrumValueTestCase(tv4, v4, "tv4 -= v2"), TestCase::QUICK);
226  AddTestCase(new SpectrumValueTestCase(tv5, v5, "tv5 *= v2"), TestCase::QUICK);
227  AddTestCase(new SpectrumValueTestCase(tv6, v6, "tv6 div= v2"), TestCase::QUICK);
228 
229  SpectrumValue tv7a(f);
230  SpectrumValue tv8a(f);
231  SpectrumValue tv9a(f);
232  SpectrumValue tv10a(f);
233  tv7a = v1 + doubleValue;
234  tv8a = v1 - doubleValue;
235  tv9a = v1 * doubleValue;
236  tv10a = v1 / doubleValue;
237  AddTestCase(new SpectrumValueTestCase(tv7a, v7, "tv7a = v1 + doubleValue"), TestCase::QUICK);
238  AddTestCase(new SpectrumValueTestCase(tv8a, v8, "tv8a = v1 - doubleValue"), TestCase::QUICK);
239  AddTestCase(new SpectrumValueTestCase(tv9a, v9, "tv9a = v1 * doubleValue"), TestCase::QUICK);
240  AddTestCase(new SpectrumValueTestCase(tv10a, v10, "tv10a = v1 div doubleValue"),
241  TestCase::QUICK);
242 
243  SpectrumValue tv7b(f);
244  SpectrumValue tv8b(f);
245  SpectrumValue tv9b(f);
246  SpectrumValue tv10b(f);
247  tv7b = doubleValue + v1;
248  tv8b = doubleValue - v1;
249  tv9b = doubleValue * v1;
250  tv10b = doubleValue / v1;
251  AddTestCase(new SpectrumValueTestCase(tv7b, v7, "tv7b = doubleValue + v1"), TestCase::QUICK);
252  AddTestCase(new SpectrumValueTestCase(tv8b, v8, "tv8b = doubleValue - v1"), TestCase::QUICK);
253  AddTestCase(new SpectrumValueTestCase(tv9b, v9, "tv9b = doubleValue * v1"), TestCase::QUICK);
254  AddTestCase(new SpectrumValueTestCase(tv10b, v10, "tv10b = doubleValue div v1"),
255  TestCase::QUICK);
256 
257  SpectrumValue v1ls3(f);
258  SpectrumValue v1rs3(f);
259  SpectrumValue tv1ls3(f);
260  SpectrumValue tv1rs3(f);
261 
262  v1ls3[0] = v1[3];
263  v1ls3[1] = v1[4];
264  tv1ls3 = v1 << 3;
265  AddTestCase(new SpectrumValueTestCase(tv1ls3, v1ls3, "tv1ls3 = v1 << 3"), TestCase::QUICK);
266 
267  v1rs3[3] = v1[0];
268  v1rs3[4] = v1[1];
269  tv1rs3 = v1 >> 3;
270  AddTestCase(new SpectrumValueTestCase(tv1rs3, v1rs3, "tv1rs3 = v1 >> 3"), TestCase::QUICK);
271 }
272 
278 class SpectrumConverterTestSuite : public TestSuite
279 {
280  public:
281  SpectrumConverterTestSuite();
282 };
283 
284 SpectrumConverterTestSuite::SpectrumConverterTestSuite()
285  : TestSuite("spectrum-converter", UNIT)
286 {
287  double f;
288 
289  std::vector<double> f1;
290  for (f = 3; f <= 7; f += 2)
291  {
292  f1.push_back(f);
293  }
294  Ptr<SpectrumModel> sof1 = Create<SpectrumModel>(f1);
295 
296  std::vector<double> f2;
297  for (f = 2; f <= 8; f += 1)
298  {
299  f2.push_back(f);
300  }
301  Ptr<SpectrumModel> sof2 = Create<SpectrumModel>(f2);
302 
303  Ptr<SpectrumValue> res;
304 
305  Ptr<SpectrumValue> v1 = Create<SpectrumValue>(sof1);
306  *v1 = 4;
307  SpectrumConverter c12(sof1, sof2);
308  res = c12.Convert(v1);
309  SpectrumValue t12(sof2);
310  t12 = 4;
311  t12[0] = 2;
312  t12[6] = 2;
313  // NS_LOG_LOGIC(*v1);
314  // NS_LOG_LOGIC(t12);
315  // NS_LOG_LOGIC(*res);
316 
317  AddTestCase(new SpectrumValueTestCase(t12, *res, ""), TestCase::QUICK);
318  // TEST_ASSERT(MoreOrLessEqual(t12, *res));
319 
320  Ptr<SpectrumValue> v2a = Create<SpectrumValue>(sof2);
321  *v2a = -2;
322  SpectrumConverter c21(sof2, sof1);
323  res = c21.Convert(v2a);
324  SpectrumValue t21a(sof1);
325  t21a = -2;
326  // NS_LOG_LOGIC(*v2a);
327  // NS_LOG_LOGIC(t21a);
328  // NS_LOG_LOGIC(*res);
329  AddTestCase(new SpectrumValueTestCase(t21a, *res, ""), TestCase::QUICK);
330  // TEST_ASSERT(MoreOrLessEqual(t21a, *res));
331 
332  Ptr<SpectrumValue> v2b = Create<SpectrumValue>(sof2);
333  (*v2b)[0] = 3;
334  (*v2b)[1] = 5;
335  (*v2b)[2] = 1;
336  (*v2b)[3] = 2;
337  (*v2b)[4] = 4;
338  (*v2b)[5] = 6;
339  (*v2b)[6] = 3;
340  res = c21.Convert(v2b);
341  SpectrumValue t21b(sof1);
342  t21b[0] = 3 * 0.25 + 5 * 0.5 + 1 * 0.25;
343  t21b[1] = 1 * 0.25 + 2 * 0.5 + 4 * 0.25;
344  t21b[2] = 4 * 0.25 + 6 * 0.5 + 3 * 0.25;
345  // NS_LOG_LOGIC(*v2b);
346  // NS_LOG_LOGIC(t21b);
347  // NS_LOG_LOGIC(*res);
348  AddTestCase(new SpectrumValueTestCase(t21b, *res, ""), TestCase::QUICK);
349 }
350 
352 static SpectrumValueTestSuite g_SpectrumValueTestSuite;
354 static SpectrumConverterTestSuite g_SpectrumConverterTestSuite;
f
double f(double x, void *params)
Definition: 80211b.c:71
SpectrumConverterTestSuite
Spectrum Converter TestSuite.
Definition: spectrum-value-test.cc:279
SpectrumValueTestCase
Spectrum Value Test.
Definition: spectrum-value-test.cc:43
SpectrumValueTestCase::MoreOrLessEqual
bool MoreOrLessEqual(SpectrumValue x, SpectrumValue y)
Check that two SpectrumValue are equal within a tolerance.
Definition: spectrum-value-test.cc:80
SpectrumValueTestCase::m_b
SpectrumValue m_b
second SpectrumValue
Definition: spectrum-value-test.cc:65
SpectrumValueTestCase::m_a
SpectrumValue m_a
first SpectrumValue
Definition: spectrum-value-test.cc:64
SpectrumValueTestCase::SpectrumValueTestCase
SpectrumValueTestCase(SpectrumValue a, SpectrumValue b, std::string name)
Constructor.
Definition: spectrum-value-test.cc:68
SpectrumValueTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: spectrum-value-test.cc:87
SpectrumValueTestSuite
Spectrum Value TestSuite.
Definition: spectrum-value-test.cc:102
ns3::SpectrumConverter
Class which implements a converter between SpectrumValue which are defined over different SpectrumMod...
Definition: spectrum-converter.h:42
ns3::SpectrumConverter::Convert
Ptr< SpectrumValue > Convert(Ptr< const SpectrumValue > vvf) const
Convert a particular ValueVsFreq instance to.
Definition: spectrum-converter.cc:79
ns3::SpectrumValue
Set of values corresponding to a given SpectrumModel.
Definition: spectrum-value.h:60
ns3::SpectrumValue::GetSpectrumModel
Ptr< const SpectrumModel > GetSpectrumModel() const
Definition: spectrum-value.cc:59
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL
#define NS_TEST_ASSERT_MSG_SPECTRUM_MODEL_EQ_TOL(actual, expected, tol, msg)
Test if two SpectrumModel instances are equal within a given tolerance.
Definition: spectrum-test.h:45
NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL
#define NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL(actual, expected, tol, msg)
Test if two SpectrumValue instances are equal within a given tolerance.
Definition: spectrum-test.h:110
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::Norm
double Norm(const SpectrumValue &x)
Definition: spectrum-value.cc:321
TOLERANCE
#define TOLERANCE
Definition: spectrum-value-test.cc:35
g_SpectrumConverterTestSuite
static SpectrumConverterTestSuite g_SpectrumConverterTestSuite
Static variable for test initialization.
Definition: spectrum-value-test.cc:354
g_SpectrumValueTestSuite
static SpectrumValueTestSuite g_SpectrumValueTestSuite
Static variable for test initialization.
Definition: spectrum-value-test.cc:352