IODA
test/io/IodaIO.h
Go to the documentation of this file.
1 /*
2  * (C) Copyright 2009-2016 ECMWF.
3  *
4  * This software is licensed under the terms of the Apache Licence Version 2.0
5  * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6  * In applying this licence, ECMWF does not waive the privileges and immunities
7  * granted to it by virtue of its status as an intergovernmental organisation nor
8  * does it submit to any jurisdiction.
9  */
10 
11 #ifndef TEST_IO_IODAIO_H_
12 #define TEST_IO_IODAIO_H_
13 
14 #include <algorithm>
15 #include <cmath>
16 #include <map>
17 #include <memory>
18 #include <string>
19 #include <typeinfo>
20 #include <vector>
21 
22 #define ECKIT_TESTING_SELF_REGISTER_CASES 0
23 
24 #include <boost/any.hpp>
25 #include <boost/noncopyable.hpp>
26 
27 #include "eckit/config/LocalConfiguration.h"
28 #include "eckit/testing/Test.h"
29 
30 #include "oops/mpi/mpi.h"
31 #include "oops/runs/Test.h"
32 #include "oops/test/TestEnvironment.h"
33 #include "oops/util/Logger.h"
34 
35 #include "ioda/io/IodaIO.h"
36 #include "ioda/io/IodaIOfactory.h"
37 
38 namespace ioda {
39 namespace test {
40 
41 // -----------------------------------------------------------------------------
42 
43 std::size_t GetMaxStringSize(const std::vector<std::string> & Strings) {
44  std::size_t MaxSize = 0;
45  for (std::size_t i = 0; i < Strings.size(); ++i) {
46  if (Strings[i].size() > MaxSize) {
47  MaxSize = Strings[i].size();
48  }
49  }
50  return MaxSize;
51 }
52 
53 // -----------------------------------------------------------------------------
54 
55 void testConstructor() {
56  const eckit::LocalConfiguration conf(::test::TestEnvironment::config());
57 
58  std::string FileName;
59  std::size_t MaxFrameSize;
60  std::unique_ptr<ioda::IodaIO> TestIO;
61 
62  std::size_t Nlocs;
63  std::size_t Nvars;
64  std::size_t ExpectedNlocs;
65  std::size_t ExpectedNvars;
66 
67  // Contructor in read mode
68  FileName = conf.getString("test input.filename");
69  MaxFrameSize = conf.getUnsigned("test input.frames.max frame size",
70  IODAIO_DEFAULT_FRAME_SIZE);
71  TestIO.reset(ioda::IodaIOfactory::Create(FileName, "r", MaxFrameSize));
72  EXPECT(TestIO.get());
73 
74  // Constructor in read mode is also responsible for setting nobs and nlocs
75  ExpectedNlocs = conf.getInt("test input.nlocs");
76  ExpectedNvars = conf.getInt("test input.nvars");
77 
78  Nlocs = TestIO->nlocs();
79  Nvars = TestIO->nvars();
80 
81  EXPECT(ExpectedNlocs == Nlocs);
82  EXPECT(ExpectedNvars == Nvars);
83 
84  // Constructor in write mode
85  FileName = conf.getString("test output.filename");
86  MaxFrameSize = conf.getUnsigned("test output.max frame size", IODAIO_DEFAULT_FRAME_SIZE);
87 
88  ExpectedNlocs = conf.getInt("test output.nlocs");
89  ExpectedNvars = conf.getInt("test output.nvars");
90 
91  TestIO.reset(ioda::IodaIOfactory::Create(FileName, "W", MaxFrameSize));
92  EXPECT(TestIO.get());
93 }
94 
95 // -----------------------------------------------------------------------------
96 
97 void testContainers() {
98  const eckit::LocalConfiguration conf(::test::TestEnvironment::config());
99  std::vector<eckit::LocalConfiguration> obstypes;
100 
101  std::string FileName;
102  std::size_t MaxFrameSize;
103  std::unique_ptr<ioda::IodaIO> TestIO;
104 
105  // Constructor in read mode will generate a group variable container,
106  // a dimension container and a frame container.
107  FileName = conf.getString("test input.filename");
108  MaxFrameSize = conf.getUnsigned("test input.frames.max frame size",
109  IODAIO_DEFAULT_FRAME_SIZE);
110  TestIO.reset(ioda::IodaIOfactory::Create(FileName, "r", MaxFrameSize));
111  EXPECT(TestIO.get());
112 
113  // Test the group, variable iterators by walking through the entire list of variables
114  // and check the count of variables (total number in the file) with the
115  // expected count.
116  std::size_t VarCount = 0;
117  std::size_t ExpectedVarCount = conf.getInt("test input.nvars");
118  for (IodaIO::GroupIter igrp = TestIO->group_begin(); igrp != TestIO->group_end(); ++igrp) {
119  std::string GroupName = TestIO->group_name(igrp);
120 
121  for (IodaIO::VarIter ivar = TestIO->var_begin(igrp); ivar != TestIO->var_end(igrp); ++ivar) {
122  VarCount++;
123  }
124  }
125  EXPECT(VarCount == ExpectedVarCount);
126 
127  // Test the dimension container. Contains dimension name, id, size.
128  std::vector<std::string> DimNames;
129  std::vector<std::size_t> DimIds;
130  std::vector<std::size_t> DimSizes;
131  std::vector<std::string> ExpectedDimNames = conf.getStringVector("test input.dimensions.names");
132  std::vector<std::size_t> ExpectedDimIds = conf.getUnsignedVector("test input.dimensions.ids");
133  std::vector<std::size_t> ExpectedDimSizes = conf.getUnsignedVector("test input.dimensions.sizes");
134  for (IodaIO::DimIter idim = TestIO->dim_begin(); idim != TestIO->dim_end(); ++idim) {
135  DimNames.push_back(TestIO->dim_name(idim));
136  DimIds.push_back(TestIO->dim_id(idim));
137  DimSizes.push_back(TestIO->dim_size(idim));
138  }
139  for (std::size_t i = 0; i < DimNames.size(); i++) {
140  EXPECT(DimNames[i] == ExpectedDimNames[i]);
141  EXPECT(DimIds[i] == ExpectedDimIds[i]);
142  EXPECT(DimSizes[i] == ExpectedDimSizes[i]);
143  }
144 
145  // Test the frame info container.
146  std::vector<std::size_t> FrameStarts = conf.getUnsignedVector("test input.frames.starts");
147  std::vector<std::size_t> FrameSizes = conf.getUnsignedVector("test input.frames.sizes");
148  std::size_t i = 0;
149  for (IodaIO::FrameIter iframe = TestIO->frame_begin();
150  iframe != TestIO->frame_end(); ++iframe) {
151  EXPECT(TestIO->frame_start(iframe) == FrameStarts[i]);
152  EXPECT(TestIO->frame_size(iframe) == FrameSizes[i]);
153  i++;
154  }
155 }
156 
157 // -----------------------------------------------------------------------------
158 
159 void testReadVar() {
160  const eckit::LocalConfiguration conf(::test::TestEnvironment::config());
161 
162  std::vector<eckit::LocalConfiguration> obstypes;
163  std::vector<std::string> GrpVarNames;
164 
165  std::unique_ptr<ioda::IodaIO> TestIO;
166 
167  // Get the input file name and the frame size.
168  std::string FileName = conf.getString("test input.filename");
169  std::size_t MaxFrameSize = conf.getUnsigned("test input.frames.max frame size",
170  IODAIO_DEFAULT_FRAME_SIZE);
171  TestIO.reset(ioda::IodaIOfactory::Create(FileName, "r", MaxFrameSize));
172 
173  // Read in the set of test variables from the configuration into a map.
174  // Create another map with the same variables to hold the data from the file.
175  // Then compare the contents of the maps to complete the test.
176  std::vector<eckit::LocalConfiguration> var_config =
177  conf.getSubConfigurations("test input.variables");
178 
179  std::map<std::string, std::vector<int>> IntVars;
180  std::map<std::string, std::vector<float>> FloatVars;
181  std::map<std::string, std::vector<std::string>> StringVars;
182 
183  std::map<std::string, std::vector<int>> ExpectedIntVars;
184  std::map<std::string, std::vector<float>> ExpectedFloatVars;
185  std::map<std::string, std::vector<std::string>> ExpectedStringVars;
186 
187  for (std::size_t i = 0; i < var_config.size(); i++) {
188  std::string VarGrpName = var_config[i].getString("name");
189  std::string VarType = var_config[i].getString("type");
190 
191  if (VarType == "int") {
192  ExpectedIntVars[VarGrpName] = var_config[i].getIntVector("values");
193  IntVars[VarGrpName] = std::vector<int>(ExpectedIntVars[VarGrpName].size(), 0);
194  } else if (VarType == "float") {
195  ExpectedFloatVars[VarGrpName] = var_config[i].getFloatVector("values");
196  FloatVars[VarGrpName] = std::vector<float>(ExpectedFloatVars[VarGrpName].size(), 0.0);
197  } else if (VarType == "string") {
198  ExpectedStringVars[VarGrpName] = var_config[i].getStringVector("values");
199  StringVars[VarGrpName] = std::vector<std::string>(ExpectedStringVars[VarGrpName].size(), "");
200  }
201  }
202 
203  TestIO->frame_initialize();
204  for (IodaIO::FrameIter iframe = TestIO->frame_begin();
205  iframe != TestIO->frame_end(); ++iframe) {
206  std::size_t FrameStart = TestIO->frame_start(iframe);
207 
208  // Fill in the current frame from the file
209  TestIO->frame_read(iframe);
210 
211  // Integer variables
212  for (IodaIO::FrameIntIter idata = TestIO->frame_int_begin();
213  idata != TestIO->frame_int_end(); ++idata) {
214  std::string VarGrpName =
215  TestIO->frame_int_get_vname(idata) + "@" + TestIO->frame_int_get_gname(idata);
216  std::vector<int> FrameData = TestIO->frame_int_get_data(idata);
217  for (std::size_t i = 0; i < FrameData.size(); ++i) {
218  IntVars[VarGrpName][FrameStart + i] = FrameData[i];
219  }
220  }
221 
222  // Float variables
223  for (IodaIO::FrameFloatIter idata = TestIO->frame_float_begin();
224  idata != TestIO->frame_float_end(); ++idata) {
225  std::string VarGrpName =
226  TestIO->frame_float_get_vname(idata) + "@" + TestIO->frame_float_get_gname(idata);
227  std::vector<float> FrameData = TestIO->frame_float_get_data(idata);
228  for (std::size_t i = 0; i < FrameData.size(); ++i) {
229  FloatVars[VarGrpName][FrameStart + i] = FrameData[i];
230  }
231  }
232 
233  // String variables
234  for (IodaIO::FrameStringIter idata = TestIO->frame_string_begin();
235  idata != TestIO->frame_string_end(); ++idata) {
236  std::string VarGrpName =
237  TestIO->frame_string_get_vname(idata) + "@" + TestIO->frame_string_get_gname(idata);
238  std::vector<std::string> FrameData = TestIO->frame_string_get_data(idata);
239  for (std::size_t i = 0; i < FrameData.size(); ++i) {
240  StringVars[VarGrpName][FrameStart + i] = FrameData[i];
241  }
242  }
243  }
244  TestIO->frame_finalize();
245 
246  // Check the variables read from the file against the expected values.
247  std::map<std::string, std::vector<int>>::iterator iint;
248  std::map<std::string, std::vector<float>>::iterator ifloat;
249  std::map<std::string, std::vector<std::string>>::iterator istring;
250 
251  for (iint = IntVars.begin(); iint != IntVars.end(); ++iint) {
252  std::vector<int> IntVect = iint->second;
253  std::vector<int> ExpectedIntVect = ExpectedIntVars[iint->first];
254  for (std::size_t i = 0; i < IntVect.size(); i++) {
255  EXPECT(IntVect[i] == ExpectedIntVect[i]);
256  }
257  }
258 
259  float FloatTol = conf.getFloat("test input.tolerance");
260  for (ifloat = FloatVars.begin(); ifloat != FloatVars.end(); ++ifloat) {
261  std::vector<float> FloatVect = ifloat->second;
262  std::vector<float> ExpectedFloatVect = ExpectedFloatVars[ifloat->first];
263  for (std::size_t i = 0; i < FloatVect.size(); i++) {
264  EXPECT(oops::is_close(FloatVect[i], ExpectedFloatVect[i], FloatTol));
265  }
266  }
267 
268  for (istring = StringVars.begin(); istring != StringVars.end(); ++istring) {
269  std::vector<std::string> StringVect = istring->second;
270  std::vector<std::string> ExpectedStringVect = ExpectedStringVars[istring->first];
271  for (std::size_t i = 0; i < StringVect.size(); i++) {
272  EXPECT(StringVect[i] == ExpectedStringVect[i]);
273  }
274  }
275 }
276 
277 // -----------------------------------------------------------------------------
278 
279 void testWriteVar() {
280  const eckit::LocalConfiguration conf(::test::TestEnvironment::config());
281  std::unique_ptr<ioda::IodaIO> TestIO;
282 
283  // Try writing variables specified in the config into a file, then read the file
284  // check that you get the same data back.
285  std::string FileName = conf.getString("test output.filename");
286  std::size_t MaxFrameSize = conf.getUnsigned("test output.max frame size",
287  IODAIO_DEFAULT_FRAME_SIZE);
288  std::size_t ExpectedNlocs = conf.getInt("test output.nlocs");
289  std::size_t ExpectedNvars = conf.getInt("test output.nvars");
290 
291  std::size_t MaxVarSize = 0;
292 
293  std::map<std::string, std::vector<int>>::iterator iint;
294  std::map<std::string, std::vector<float>>::iterator ifloat;
295  std::map<std::string, std::vector<std::string>>::iterator istring;
296 
297  std::map<std::string, std::vector<int>> IntVars;
298  std::map<std::string, std::vector<float>> FloatVars;
299  std::map<std::string, std::vector<std::string>> StringVars;
300 
301  std::map<std::string, std::vector<int>> ExpectedIntVars;
302  std::map<std::string, std::vector<float>> ExpectedFloatVars;
303  std::map<std::string, std::vector<std::string>> ExpectedStringVars;
304 
305  // Read in the variable data
306  std::vector<eckit::LocalConfiguration> var_config =
307  conf.getSubConfigurations("test output.variables");
308 
309  for (std::size_t i = 0; i < var_config.size(); i++) {
310  std::string VarGrpName = var_config[i].getString("name");
311  std::string VarType = var_config[i].getString("type");
312 
313  if (VarType == "int") {
314  ExpectedIntVars[VarGrpName] = var_config[i].getIntVector("values");
315  IntVars[VarGrpName] = std::vector<int>(ExpectedIntVars[VarGrpName].size(), 0);
316  MaxVarSize = std::max(MaxVarSize, ExpectedIntVars[VarGrpName].size());
317  } else if (VarType == "float") {
318  ExpectedFloatVars[VarGrpName] = var_config[i].getFloatVector("values");
319  FloatVars[VarGrpName] = std::vector<float>(ExpectedFloatVars[VarGrpName].size(), 0.0);
320  MaxVarSize = std::max(MaxVarSize, ExpectedFloatVars[VarGrpName].size());
321  } else if (VarType == "string") {
322  ExpectedStringVars[VarGrpName] = var_config[i].getStringVector("values");
323  StringVars[VarGrpName] = std::vector<std::string>(ExpectedStringVars[VarGrpName].size(), "");
324  MaxVarSize = std::max(MaxVarSize, ExpectedStringVars[VarGrpName].size());
325  }
326  }
327 
328  // Write the test data into the file. When writing, need to initialize the frame info
329  // container, the dim info container and the group,variable info container.
330  TestIO.reset(ioda::IodaIOfactory::Create(FileName, "W", MaxFrameSize));
331  TestIO->frame_info_init(MaxVarSize);
332  TestIO->dim_insert("nlocs", ExpectedNlocs);
333  TestIO->dim_insert("nvars", ExpectedNvars);
334 
335  std::string GroupName;
336  std::string VarName;
337  for (iint = ExpectedIntVars.begin(); iint != ExpectedIntVars.end(); ++iint) {
338  TestIO->ExtractGrpVarName(iint->first, GroupName, VarName);
339  std::vector<std::size_t> VarShape(1, (iint->second).size());
340  TestIO->grp_var_insert(GroupName, VarName, "int", VarShape, iint->first, "int");
341  }
342  for (ifloat = ExpectedFloatVars.begin(); ifloat != ExpectedFloatVars.end(); ++ifloat) {
343  TestIO->ExtractGrpVarName(ifloat->first, GroupName, VarName);
344  std::vector<std::size_t> VarShape(1, (ifloat->second).size());
345  TestIO->grp_var_insert(GroupName, VarName, "float", VarShape, ifloat->first, "float");
346  }
347  for (istring = ExpectedStringVars.begin(); istring != ExpectedStringVars.end(); ++istring) {
348  TestIO->ExtractGrpVarName(istring->first, GroupName, VarName);
349  std::vector<std::size_t> VarShape(1, (istring->second).size());
350  std::size_t MaxStringSize = GetMaxStringSize(istring->second);
351  TestIO->grp_var_insert(GroupName, VarName, "string", VarShape, istring->first, "string",
352  MaxStringSize);
353  }
354 
355  for (IodaIO::FrameIter iframe = TestIO->frame_begin();
356  iframe != TestIO->frame_end(); ++iframe) {
357  TestIO->frame_data_init();
358  std::size_t FrameStart = TestIO->frame_start(iframe);
359  std::size_t FrameSize = TestIO->frame_size(iframe);
360 
361  for (iint = ExpectedIntVars.begin(); iint != ExpectedIntVars.end(); ++iint) {
362  TestIO->ExtractGrpVarName(iint->first, GroupName, VarName);
363  std::vector<std::size_t> VarShape = TestIO->var_shape(GroupName, VarName);
364 
365  if (VarShape[0] > FrameStart) {
366  std::size_t VarSize;
367  if (FrameStart + FrameSize > VarShape[0]) {
368  VarSize = VarShape[0] - FrameStart;
369  } else {
370  VarSize = FrameSize;
371  }
372 
373  std::vector<int>::iterator Start = ExpectedIntVars[iint->first].begin() + FrameStart;
374  std::vector<int>::iterator End = Start + VarSize;
375  std::vector<int> FrameData(Start, End);
376  TestIO->frame_int_put_data(GroupName, VarName, FrameData);
377  }
378  }
379 
380  for (ifloat = ExpectedFloatVars.begin(); ifloat != ExpectedFloatVars.end(); ++ifloat) {
381  TestIO->ExtractGrpVarName(ifloat->first, GroupName, VarName);
382  std::vector<std::size_t> VarShape = TestIO->var_shape(GroupName, VarName);
383 
384  if (VarShape[0] > FrameStart) {
385  std::size_t VarSize;
386  if (FrameStart + FrameSize > VarShape[0]) {
387  VarSize = VarShape[0] - FrameStart;
388  } else {
389  VarSize = FrameSize;
390  }
391 
392  std::vector<float>::iterator Start =
393  ExpectedFloatVars[ifloat->first].begin() + FrameStart;
394  std::vector<float>::iterator End = Start + VarSize;
395  std::vector<float> FrameData(Start, End);
396  TestIO->frame_float_put_data(GroupName, VarName, FrameData);
397  }
398  }
399 
400  for (istring = ExpectedStringVars.begin(); istring != ExpectedStringVars.end(); ++istring) {
401  TestIO->ExtractGrpVarName(istring->first, GroupName, VarName);
402  std::vector<std::size_t> VarShape = TestIO->var_shape(GroupName, VarName);
403 
404  if (VarShape[0] > FrameStart) {
405  std::size_t VarSize;
406  if (FrameStart + FrameSize > VarShape[0]) {
407  VarSize = VarShape[0] - FrameStart;
408  } else {
409  VarSize = FrameSize;
410  }
411 
412  std::vector<std::string>::iterator Start =
413  ExpectedStringVars[istring->first].begin() + FrameStart;
414  std::vector<std::string>::iterator End = Start + VarSize;
415  std::vector<std::string> FrameData(Start, End);
416  TestIO->frame_string_put_data(GroupName, VarName, FrameData);
417  }
418  }
419 
420  // Write the frame into the file
421  TestIO->frame_write(iframe);
422  }
423 
424  // Read the data from the file we just created.
425  TestIO.reset(ioda::IodaIOfactory::Create(FileName, "r", MaxFrameSize));
426  TestIO->frame_initialize();
427  for (IodaIO::FrameIter iframe = TestIO->frame_begin();
428  iframe != TestIO->frame_end(); ++iframe) {
429  std::size_t FrameStart = TestIO->frame_start(iframe);
430  std::size_t FrameSize = TestIO->frame_size(iframe);
431 
432  // Fill in the current frame from the file
433  TestIO->frame_read(iframe);
434 
435  // Integer variables
436  for (IodaIO::FrameIntIter idata = TestIO->frame_int_begin();
437  idata != TestIO->frame_int_end(); ++idata) {
438  std::string GroupName = TestIO->frame_int_get_gname(idata);
439  std::string VarName = TestIO->frame_int_get_vname(idata);
440  std::vector<int> FrameData;
441  TestIO->frame_int_get_data(GroupName, VarName, FrameData);
442 
443  std::string VarGrpName = VarName + "@" + GroupName;
444  for (std::size_t i = 0; i < FrameData.size(); ++i) {
445  IntVars[VarGrpName][FrameStart + i] = FrameData[i];
446  }
447  }
448 
449  // Float variables
450  for (IodaIO::FrameFloatIter idata = TestIO->frame_float_begin();
451  idata != TestIO->frame_float_end(); ++idata) {
452  std::string GroupName = TestIO->frame_float_get_gname(idata);
453  std::string VarName = TestIO->frame_float_get_vname(idata);
454  std::vector<float> FrameData;
455  TestIO->frame_float_get_data(GroupName, VarName, FrameData);
456 
457  std::string VarGrpName = VarName + "@" + GroupName;
458  for (std::size_t i = 0; i < FrameData.size(); ++i) {
459  FloatVars[VarGrpName][FrameStart + i] = FrameData[i];
460  }
461  }
462 
463  // String variables
464  for (IodaIO::FrameStringIter idata = TestIO->frame_string_begin();
465  idata != TestIO->frame_string_end(); ++idata) {
466  std::string GroupName = TestIO->frame_string_get_gname(idata);
467  std::string VarName = TestIO->frame_string_get_vname(idata);
468  std::vector<std::string> FrameData;
469  TestIO->frame_string_get_data(GroupName, VarName, FrameData);
470 
471  std::string VarGrpName = VarName + "@" + GroupName;
472  for (std::size_t i = 0; i < FrameData.size(); ++i) {
473  StringVars[VarGrpName][FrameStart + i] = FrameData[i];
474  }
475  }
476  }
477  TestIO->frame_finalize();
478 
479  // Check the variables read from the file against the expected values.
480  for (iint = IntVars.begin(); iint != IntVars.end(); ++iint) {
481  std::vector<int> IntVect = iint->second;
482  std::vector<int> ExpectedIntVect = ExpectedIntVars[iint->first];
483  for (std::size_t i = 0; i < IntVect.size(); i++) {
484  EXPECT(IntVect[i] == ExpectedIntVect[i]);
485  }
486  }
487 
488  float FloatTol = conf.getFloat("test output.tolerance");
489  for (ifloat = FloatVars.begin(); ifloat != FloatVars.end(); ++ifloat) {
490  std::vector<float> FloatVect = ifloat->second;
491  std::vector<float> ExpectedFloatVect = ExpectedFloatVars[ifloat->first];
492  for (std::size_t i = 0; i < FloatVect.size(); i++) {
493  EXPECT(oops::is_close(FloatVect[i], ExpectedFloatVect[i], FloatTol));
494  }
495  }
496 
497  for (istring = StringVars.begin(); istring != StringVars.end(); ++istring) {
498  std::vector<std::string> StringVect = istring->second;
499  std::vector<std::string> ExpectedStringVect = ExpectedStringVars[istring->first];
500  for (std::size_t i = 0; i < StringVect.size(); i++) {
501  EXPECT(StringVect[i] == ExpectedStringVect[i]);
502  }
503  }
504 }
505 
506 // -----------------------------------------------------------------------------
507 
508 class IodaIO : public oops::Test {
509  public:
510  IodaIO() {}
511  virtual ~IodaIO() {}
512  private:
513  std::string testid() const override {return "test::IodaIO";}
514 
515  void register_tests() const override {
516  std::vector<eckit::testing::Test>& ts = eckit::testing::specification();
517 
518  ts.emplace_back(CASE("io/IodaIO/testConstructor")
519  { testConstructor(); });
520  ts.emplace_back(CASE("io/IodaIO/testContainers")
521  { testContainers(); });
522  ts.emplace_back(CASE("io/IodaIO/testReadVar")
523  { testReadVar(); });
524  ts.emplace_back(CASE("io/IodaIO/testWriteVar")
525  { testWriteVar(); });
526  }
527 
528  void clear() const override {}
529 };
530 
531 // -----------------------------------------------------------------------------
532 
533 } // namespace test
534 } // namespace ioda
535 
536 #endif // TEST_IO_IODAIO_H_
ioda::IodaIO::VarIter
VarInfoMap::const_iterator VarIter
group-variable map, variable iterator
Definition: src/io/IodaIO.h:230
ioda::IodaIO::FrameIntIter
FrameDataMap< int >::FrameStoreIter FrameIntIter
Definition: src/io/IodaIO.h:291
ioda::IodaIO::GroupIter
GroupVarInfoMap::const_iterator GroupIter
group-variable map, group iterator
Definition: src/io/IodaIO.h:218
ioda::IodaIOfactory::Create
static ioda::IodaIO * Create(const std::string &FileName, const std::string &FileMode, const std::size_t MaxFrameSize)
Instantiate a IodaIO object.
Definition: IodaIOfactory.cc:29
ioda::test::IodaIO::IodaIO
IodaIO()
Definition: test/io/IodaIO.h:510
ioda::test::testWriteVar
void testWriteVar()
Definition: test/io/IodaIO.h:279
ioda::IODAIO_DEFAULT_FRAME_SIZE
const std::size_t IODAIO_DEFAULT_FRAME_SIZE
Constant to be used for default maximum frame size.
Definition: IodaIOfactory.h:20
ioda::IodaIO::FrameIter
FrameInfo::const_iterator FrameIter
Definition: src/io/IodaIO.h:275
ioda::test::IodaIO
Definition: test/io/IodaIO.h:508
ioda::test::testReadVar
void testReadVar()
Definition: test/io/IodaIO.h:159
ioda
Definition: IodaUtils.cc:13
ioda::test::testContainers
void testContainers()
Definition: test/io/IodaIO.h:97
ioda::test::IodaIO::~IodaIO
virtual ~IodaIO()
Definition: test/io/IodaIO.h:511
ioda::test::IodaIO::clear
void clear() const override
Definition: test/io/IodaIO.h:528
ioda::test::testConstructor
void testConstructor()
Definition: test/core/ObsSpaceContainer.h:76
ioda::IodaIO::FrameStringIter
FrameDataMap< std::string >::FrameStoreIter FrameStringIter
Definition: src/io/IodaIO.h:341
ioda::test::GetMaxStringSize
std::size_t GetMaxStringSize(const std::vector< std::string > &Strings)
Definition: test/io/IodaIO.h:43
ioda::IodaIO::FrameFloatIter
FrameDataMap< float >::FrameStoreIter FrameFloatIter
Definition: src/io/IodaIO.h:316
ioda::test::IodaIO::testid
std::string testid() const override
Definition: test/io/IodaIO.h:513
ioda::IodaIO::DimIter
DimInfoMap::const_iterator DimIter
Definition: src/io/IodaIO.h:256
ioda::test::IodaIO::register_tests
void register_tests() const override
Definition: test/io/IodaIO.h:515