2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2011,2012,2013,2014, by the GROMACS development team, led by
5 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
6 * and including many others, as listed in the AUTHORS file in the
7 * top-level source directory and at http://www.gromacs.org.
9 * GROMACS is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public License
11 * as published by the Free Software Foundation; either version 2.1
12 * of the License, or (at your option) any later version.
14 * GROMACS is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with GROMACS; if not, see
21 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 * If you want to redistribute modifications to GROMACS, please
25 * consider that scientific software is very special. Version
26 * control is crucial - bugs must be traceable. We will be happy to
27 * consider code for inclusion in the official distribution, but
28 * derived work must not be called official GROMACS. Details are found
29 * in the README & COPYING files - if they are missing, get the
30 * official version at http://www.gromacs.org.
32 * To help us fund GROMACS development, we humbly ask that you cite
33 * the research papers on the package. Check out http://www.gromacs.org.
37 * Implements classes and functions from refdata.h.
39 * \author Teemu Murtola <teemu.murtola@gmail.com>
40 * \ingroup module_testutils
50 #include <gtest/gtest.h>
51 #include <libxml/parser.h>
52 #include <libxml/xmlmemory.h>
54 #include "gromacs/fileio/path.h"
55 #include "gromacs/options/basicoptions.h"
56 #include "gromacs/options/options.h"
57 #include "gromacs/utility/exceptions.h"
58 #include "gromacs/utility/gmxassert.h"
59 #include "gromacs/utility/stringutil.h"
61 #include "testutils/testasserts.h"
62 #include "testutils/testexceptions.h"
63 #include "testutils/testfilemanager.h"
69 * Global test environment for freeing up libxml2 internal buffers.
71 class TestReferenceDataEnvironment : public ::testing::Environment
74 //! Frees internal buffers allocated by libxml2.
75 virtual void TearDown()
81 //! Global reference data mode set with gmx::test::setReferenceDataMode().
82 // TODO: Make this a real enum; requires solving a TODO in StringOption.
83 int g_referenceDataMode = gmx::test::erefdataCompare;
92 ReferenceDataMode getReferenceDataMode()
94 return static_cast<ReferenceDataMode>(g_referenceDataMode);
97 void setReferenceDataMode(ReferenceDataMode mode)
99 g_referenceDataMode = mode;
102 std::string getReferenceDataPath()
104 return TestFileManager::getInputFilePath("refdata");
107 void initReferenceData(Options *options)
109 // Needs to correspond to the enum order in refdata.h.
110 const char *const refDataEnum[] = { "check", "create", "update" };
112 StringOption("ref-data").enumValue(refDataEnum)
114 .storeEnumIndex(&g_referenceDataMode)
115 .description("Operation mode for tests that use reference data"));
116 ::testing::AddGlobalTestEnvironment(new TestReferenceDataEnvironment);
119 /********************************************************************
120 * TestReferenceData::Impl
124 * Private implementation class for TestReferenceData.
126 * \ingroup module_testutils
128 class TestReferenceData::Impl
131 //! String constant for output XML version string.
132 static const xmlChar * const cXmlVersion;
133 //! String constant for XML stylesheet processing instruction name.
134 static const xmlChar * const cXmlStyleSheetNodeName;
135 //! String constant for XML stylesheet reference.
136 static const xmlChar * const cXmlStyleSheetContent;
137 //! String constant for naming the root XML element.
138 static const xmlChar * const cRootNodeName;
140 //! Initializes a checker in the given mode.
141 Impl(ReferenceDataMode mode, bool bSelfTestMode);
144 //! Full path of the reference data file.
145 std::string fullFilename_;
147 * XML document for the reference data.
149 * May be NULL if there was an I/O error in initialization.
153 * Whether the reference data is being written (true) or compared
157 //! `true` if self-testing (enables extra failure messages).
160 * Whether any reference checkers have been created for this data.
165 const xmlChar * const TestReferenceData::Impl::cXmlVersion =
166 (const xmlChar *)"1.0";
167 const xmlChar * const TestReferenceData::Impl::cXmlStyleSheetNodeName =
168 (const xmlChar *)"xml-stylesheet";
169 const xmlChar * const TestReferenceData::Impl::cXmlStyleSheetContent =
170 (const xmlChar *)"type=\"text/xsl\" href=\"referencedata.xsl\"";
171 const xmlChar * const TestReferenceData::Impl::cRootNodeName =
172 (const xmlChar *)"ReferenceData";
175 TestReferenceData::Impl::Impl(ReferenceDataMode mode, bool bSelfTestMode)
176 : refDoc_(NULL), bWrite_(false), bSelfTestMode_(bSelfTestMode), bInUse_(false)
178 std::string dirname = getReferenceDataPath();
179 std::string filename = TestFileManager::getTestSpecificFileName(".xml");
180 fullFilename_ = Path::join(dirname, filename);
183 if (mode != erefdataUpdateAll)
185 FILE *fp = std::fopen(fullFilename_.c_str(), "r");
191 else if (mode == erefdataCompare)
199 // TODO: Error checking
200 refDoc_ = xmlNewDoc(cXmlVersion);
201 xmlNodePtr rootNode = xmlNewDocNode(refDoc_, NULL, cRootNodeName, NULL);
202 xmlDocSetRootElement(refDoc_, rootNode);
203 xmlNodePtr xslNode = xmlNewDocPI(refDoc_, cXmlStyleSheetNodeName,
204 cXmlStyleSheetContent);
205 xmlAddPrevSibling(rootNode, xslNode);
209 refDoc_ = xmlParseFile(fullFilename_.c_str());
212 GMX_THROW(TestException("Reference data not parsed successfully: " + fullFilename_));
214 xmlNodePtr rootNode = xmlDocGetRootElement(refDoc_);
215 if (rootNode == NULL)
218 GMX_THROW(TestException("Reference data is empty: " + fullFilename_));
220 if (xmlStrcmp(rootNode->name, cRootNodeName) != 0)
223 GMX_THROW(TestException("Invalid root node type in " + fullFilename_));
229 TestReferenceData::Impl::~Impl()
231 if (bWrite_ && bInUse_ && refDoc_ != NULL)
233 std::string dirname = getReferenceDataPath();
234 if (!Directory::exists(dirname))
236 if (Directory::create(dirname) != 0)
238 ADD_FAILURE() << "Creation of reference data directory failed for " << dirname;
241 if (xmlSaveFormatFile(fullFilename_.c_str(), refDoc_, 1) == -1)
243 ADD_FAILURE() << "Saving reference data failed for " + fullFilename_;
253 /********************************************************************
254 * TestReferenceChecker::Impl
258 * Private implementation class for TestReferenceChecker.
260 * \ingroup module_testutils
262 class TestReferenceChecker::Impl
265 //! String constant for naming XML elements for boolean values.
266 static const xmlChar * const cBooleanNodeName;
267 //! String constant for naming XML elements for string values.
268 static const xmlChar * const cStringNodeName;
269 //! String constant for naming XML elements for integer values.
270 static const xmlChar * const cIntegerNodeName;
271 //! String constant for naming XML elements for floating-point values.
272 static const xmlChar * const cRealNodeName;
273 //! String constant for naming XML attribute for value identifiers.
274 static const xmlChar * const cIdAttrName;
275 //! String constant for naming compounds for vectors.
276 static const char * const cVectorType;
277 //! String constant for naming compounds for sequences.
278 static const char * const cSequenceType;
279 //! String constant for value identifier for sequence length.
280 static const char * const cSequenceLengthName;
282 //! Creates a checker that does nothing.
283 explicit Impl(bool bWrite);
284 //! Creates a checker with a given root node.
285 Impl(const std::string &path, xmlNodePtr rootNode, bool bWrite,
286 bool bSelfTestMode, const FloatingPointTolerance &defaultTolerance);
288 //! Returns a string for SCOPED_TRACE() for checking element \p id.
289 std::string traceString(const char *id) const;
290 //! Returns the path of this checker with \p id appended.
291 std::string appendPath(const char *id) const;
294 * Finds a reference data node.
296 * \param[in] name Type of node to find (can be NULL, in which case
297 * any type is matched).
298 * \param[in] id Unique identifier of the node (can be NULL, in
299 * which case the next node without an id is matched).
300 * \returns Matching node, or NULL if no matching node found.
302 * Searches for a node in the reference data that matches the given
303 * \p name and \p id. Searching starts from the node that follows the
304 * previously matched node (relevant for performance, and if there are
305 * duplicate ids or nodes without ids). Note that the match pointer is
306 * not updated by this method.
308 xmlNodePtr findNode(const xmlChar *name, const char *id) const;
310 * Finds/creates a reference data node to match against.
312 * \param[in] name Type of node to find.
313 * \param[in] id Unique identifier of the node (can be NULL, in
314 * which case the next node without an id is matched).
315 * \param[out] bFound Whether the node was found (false if the node was
316 * created in write mode).
317 * \returns Matching node, or NULL if no matching node found
318 * (NULL is never returned in write mode).
319 * \throws TestException if node creation fails in write mode.
321 * Finds a node using findNode() and updates the match pointer is a
322 * match is found. If a match is not found, the method returns NULL in
323 * read mode and creates a new node in write mode. If the creation
324 * fails in write mode, throws.
326 xmlNodePtr findOrCreateNode(const xmlChar *name, const char *id,
329 * Helper method for checking a reference data value.
331 * \param[in] name Type of node to find.
332 * \param[in] id Unique identifier of the node (can be NULL, in
333 * which case the next node without an id is matched).
334 * \param[in] value String value of the value to be compared.
335 * \param[out] bFound true if a matchin value was found.
336 * \returns String value for the reference value.
337 * \throws TestException if node creation fails in write mode.
339 * Performs common tasks in checking a reference value:
340 * finding/creating the correct XML node and reading/writing its string
341 * value. Caller is responsible for converting the value to and from
342 * string where necessary and performing the actual comparison.
344 * In read mode, if a value is not found, adds a Google Test failure
345 * and returns an empty string. If the reference value is found,
346 * returns it (\p value is not used in this case).
348 * In write mode, creates the node if it is not found, sets its value
349 * as \p value and returns \p value.
351 std::string processItem(const xmlChar *name, const char *id,
352 const char *value, bool *bFound);
353 //! Convenience wrapper that takes a std::string.
354 std::string processItem(const xmlChar *name, const char *id,
355 const std::string &value, bool *bFound);
357 * Whether the checker should ignore all validation calls.
359 * This is used to ignore any calls within compounds for which
360 * reference data could not be found, such that only one error is
361 * issued for the missing compound, instead of every individual value.
363 bool shouldIgnore() const;
365 //! Default floating-point comparison tolerance.
366 FloatingPointTolerance defaultTolerance_;
368 * Human-readable path to the root node of this checker.
370 * For the root checker, this will be "/", and for each compound, the
371 * id of the compound is added. Used for reporting comparison
376 * Current node under which reference data is searched.
378 * Points to either the root of TestReferenceData::Impl::refDoc_, or to
381 * Can be NULL, in which case this checker does nothing (doesn't even
382 * report errors, see shouldIgnore()).
384 xmlNodePtr currNode_;
386 * Points to a child of \a currNode_ that was last found.
388 * On initialization, is initialized to NULL. After every check, is
389 * updated to point to the node that was used for the check.
390 * Subsequent checks start the search for the matching node on this
393 * Is NULL if \a currNode_ contains no children or if no checks have
395 * Otherwise, always points to a direct child of \a currNode_.
397 xmlNodePtr prevFoundNode_;
399 * Whether the reference data is being written (true) or compared
403 //! `true` if self-testing (enables extra failure messages).
406 * Current number of unnamed elements in a sequence.
408 * It is the index of the next added unnamed element.
413 const xmlChar * const TestReferenceChecker::Impl::cBooleanNodeName =
414 (const xmlChar *)"Bool";
415 const xmlChar * const TestReferenceChecker::Impl::cStringNodeName =
416 (const xmlChar *)"String";
417 const xmlChar * const TestReferenceChecker::Impl::cIntegerNodeName =
418 (const xmlChar *)"Int";
419 const xmlChar * const TestReferenceChecker::Impl::cRealNodeName =
420 (const xmlChar *)"Real";
421 const xmlChar * const TestReferenceChecker::Impl::cIdAttrName =
422 (const xmlChar *)"Name";
423 const char * const TestReferenceChecker::Impl::cVectorType =
425 const char * const TestReferenceChecker::Impl::cSequenceType =
427 const char * const TestReferenceChecker::Impl::cSequenceLengthName =
431 TestReferenceChecker::Impl::Impl(bool bWrite)
432 : defaultTolerance_(defaultRealTolerance()),
433 currNode_(NULL), prevFoundNode_(NULL), bWrite_(bWrite),
434 bSelfTestMode_(false), seqIndex_(0)
439 TestReferenceChecker::Impl::Impl(const std::string &path, xmlNodePtr rootNode,
440 bool bWrite, bool bSelfTestMode,
441 const FloatingPointTolerance &defaultTolerance)
442 : defaultTolerance_(defaultTolerance), path_(path + "/"),
443 currNode_(rootNode), prevFoundNode_(NULL), bWrite_(bWrite),
444 bSelfTestMode_(bSelfTestMode), seqIndex_(0)
450 TestReferenceChecker::Impl::traceString(const char *id) const
452 return "Checking '" + appendPath(id) + "'";
457 TestReferenceChecker::Impl::appendPath(const char *id) const
459 std::string printId = (id != NULL) ? id : formatString("[%d]", seqIndex_);
460 return path_ + printId;
465 TestReferenceChecker::Impl::findNode(const xmlChar *name, const char *id) const
467 if (currNode_ == NULL || currNode_->children == NULL)
471 const xmlChar *xmlId = reinterpret_cast<const xmlChar *>(id);
472 xmlNodePtr node = prevFoundNode_;
478 xmlChar *refId = xmlGetProp(node, cIdAttrName);
481 if (name == NULL || xmlStrcmp(node->name, name) == 0)
499 node = currNode_->children;
504 if (name == NULL || xmlStrcmp(node->name, name) == 0)
506 xmlChar *refId = xmlGetProp(node, cIdAttrName);
507 if (xmlId == NULL && refId == NULL)
513 if (xmlId != NULL && xmlStrcmp(refId, xmlId) == 0)
522 if (bWrap && node == NULL)
524 node = currNode_->children;
527 while (node != NULL && node != prevFoundNode_);
533 TestReferenceChecker::Impl::findOrCreateNode(const xmlChar *name,
538 xmlNodePtr node = findNode(name, id);
542 prevFoundNode_ = node;
548 node = xmlNewTextChild(currNode_, NULL, name, NULL);
549 if (node != NULL && id != NULL)
551 const xmlChar *xmlId = reinterpret_cast<const xmlChar *>(id);
552 xmlAttrPtr prop = xmlNewProp(node, cIdAttrName, xmlId);
561 GMX_THROW(TestException("XML node creation failed"));
563 prevFoundNode_ = node;
567 ADD_FAILURE() << "Reference data item not found";
570 seqIndex_ = (id == NULL) ? seqIndex_+1 : 0;
577 TestReferenceChecker::Impl::processItem(const xmlChar *name, const char *id,
578 const char *value, bool *bFound)
580 xmlNodePtr node = findOrCreateNode(name, id, bFound);
583 return std::string();
585 if (bWrite_ && !*bFound)
587 xmlNodeAddContent(node, reinterpret_cast<const xmlChar *>(value));
589 return std::string(value);
593 xmlChar *refXmlValue = xmlNodeGetContent(node);
594 std::string refValue(reinterpret_cast<const char *>(refXmlValue));
595 xmlFree(refXmlValue);
602 TestReferenceChecker::Impl::processItem(const xmlChar *name, const char *id,
603 const std::string &value, bool *bFound)
605 return processItem(name, id, value.c_str(), bFound);
610 TestReferenceChecker::Impl::shouldIgnore() const
612 return currNode_ == NULL;
616 /********************************************************************
620 TestReferenceData::TestReferenceData()
621 : impl_(new Impl(getReferenceDataMode(), false))
626 TestReferenceData::TestReferenceData(ReferenceDataMode mode)
627 : impl_(new Impl(mode, true))
632 TestReferenceData::~TestReferenceData()
637 bool TestReferenceData::isWriteMode() const
639 return impl_->bWrite_;
643 TestReferenceChecker TestReferenceData::rootChecker()
645 if (!isWriteMode() && !impl_->bInUse_ && impl_->refDoc_ == NULL)
647 ADD_FAILURE() << "Reference data file not found: "
648 << impl_->fullFilename_;
650 impl_->bInUse_ = true;
651 if (impl_->refDoc_ == NULL)
653 return TestReferenceChecker(new TestReferenceChecker::Impl(isWriteMode()));
655 xmlNodePtr rootNode = xmlDocGetRootElement(impl_->refDoc_);
656 // TODO: The default tolerance for double-precision builds that explicitly
657 // call checkFloat() may not be ideal.
658 return TestReferenceChecker(
659 new TestReferenceChecker::Impl("", rootNode, isWriteMode(),
660 impl_->bSelfTestMode_,
661 defaultRealTolerance()));
665 /********************************************************************
666 * TestReferenceChecker
669 TestReferenceChecker::TestReferenceChecker(Impl *impl)
675 TestReferenceChecker::TestReferenceChecker(const TestReferenceChecker &other)
676 : impl_(new Impl(*other.impl_))
681 TestReferenceChecker &
682 TestReferenceChecker::operator=(const TestReferenceChecker &other)
684 impl_.reset(new Impl(*other.impl_));
689 TestReferenceChecker::~TestReferenceChecker()
694 bool TestReferenceChecker::isWriteMode() const
696 return impl_->bWrite_;
700 void TestReferenceChecker::setDefaultTolerance(
701 const FloatingPointTolerance &tolerance)
703 impl_->defaultTolerance_ = tolerance;
707 bool TestReferenceChecker::checkPresent(bool bPresent, const char *id)
709 if (isWriteMode() || impl_->shouldIgnore())
713 xmlNodePtr node = impl_->findNode(NULL, id);
714 bool bFound = (node != NULL);
715 if (bFound != bPresent)
717 ADD_FAILURE() << "Mismatch while checking reference data item '"
718 << impl_->appendPath(id) << "'\n"
719 << "Expected: " << (bPresent ? "it is present.\n" : "it is absent.\n")
720 << " Actual: " << (bFound ? "it is present." : "it is absent.");
722 if (bFound && bPresent)
724 impl_->prevFoundNode_ = node;
731 TestReferenceChecker TestReferenceChecker::checkCompound(const char *type, const char *id)
733 SCOPED_TRACE(impl_->traceString(id));
734 if (impl_->shouldIgnore())
736 return TestReferenceChecker(new Impl(isWriteMode()));
738 const xmlChar *xmlNodeName = reinterpret_cast<const xmlChar *>(type);
740 xmlNodePtr newNode = impl_->findOrCreateNode(xmlNodeName, id, &bFound);
743 return TestReferenceChecker(new Impl(isWriteMode()));
745 return TestReferenceChecker(
746 new Impl(impl_->appendPath(id), newNode, isWriteMode(),
747 impl_->bSelfTestMode_, impl_->defaultTolerance_));
751 void TestReferenceChecker::checkBoolean(bool value, const char *id)
753 if (impl_->shouldIgnore())
757 SCOPED_TRACE(impl_->traceString(id));
759 const char *strValue = value ? "true" : "false";
760 std::string refStrValue =
761 impl_->processItem(Impl::cBooleanNodeName, id, strValue, &bFound);
764 EXPECT_EQ(refStrValue, strValue);
769 void TestReferenceChecker::checkString(const char *value, const char *id)
771 if (impl_->shouldIgnore())
775 SCOPED_TRACE(impl_->traceString(id));
777 std::string refStrValue =
778 impl_->processItem(Impl::cStringNodeName, id, value, &bFound);
781 EXPECT_EQ(refStrValue, value);
786 void TestReferenceChecker::checkString(const std::string &value, const char *id)
788 checkString(value.c_str(), id);
792 void TestReferenceChecker::checkStringBlock(const std::string &value,
795 if (impl_->shouldIgnore())
799 SCOPED_TRACE(impl_->traceString(id));
801 xmlNodePtr node = impl_->findOrCreateNode(Impl::cStringNodeName, id, &bFound);
806 // An extra newline is written in the beginning to make lines align
807 // in the output xml (otherwise, the first line would be off by the length
808 // of the starting CDATA tag).
809 if (isWriteMode() && !bFound)
811 std::string adjustedValue = "\n" + value;
812 const xmlChar *xmlValue
813 = reinterpret_cast<const xmlChar *>(adjustedValue.c_str());
814 // TODO: Figure out if \r and \r\n can be handled without them changing
815 // to \n in the roundtrip
817 = xmlNewCDataBlock(node->doc, xmlValue,
818 static_cast<int>(adjustedValue.length()));
819 xmlAddChild(node, cdata);
823 xmlNodePtr cdata = node->children;
824 while (cdata != NULL && cdata->type != XML_CDATA_SECTION_NODE)
830 ADD_FAILURE() << "Invalid string block element";
833 xmlChar *refXmlValue = xmlNodeGetContent(cdata);
834 if (refXmlValue[0] != '\n')
836 ADD_FAILURE() << "Invalid string block element";
837 xmlFree(refXmlValue);
840 std::string refValue(reinterpret_cast<const char *>(refXmlValue + 1));
841 xmlFree(refXmlValue);
842 EXPECT_EQ(refValue, value);
847 void TestReferenceChecker::checkInteger(int value, const char *id)
849 if (impl_->shouldIgnore())
853 SCOPED_TRACE(impl_->traceString(id));
855 std::string strValue = formatString("%d", value);
856 std::string refStrValue =
857 impl_->processItem(Impl::cIntegerNodeName, id, strValue, &bFound);
860 EXPECT_EQ(refStrValue, strValue);
865 void TestReferenceChecker::checkDouble(double value, const char *id)
867 if (impl_->shouldIgnore())
871 SCOPED_TRACE(impl_->traceString(id));
873 const int prec = std::numeric_limits<double>::digits10 + 2;
874 std::string strValue = formatString("%.*g", prec, value);
875 std::string refStrValue =
876 impl_->processItem(Impl::cRealNodeName, id, strValue, &bFound);
880 double refValue = std::strtod(refStrValue.c_str(), &endptr);
881 EXPECT_EQ('\0', *endptr);
882 if (impl_->bSelfTestMode_)
884 EXPECT_DOUBLE_EQ_TOL(refValue, value, impl_->defaultTolerance_)
885 << "String value: " << strValue << std::endl
886 << " Ref. string: " << refStrValue;
890 EXPECT_DOUBLE_EQ_TOL(refValue, value, impl_->defaultTolerance_);
896 void TestReferenceChecker::checkFloat(float value, const char *id)
898 if (impl_->shouldIgnore())
902 SCOPED_TRACE(impl_->traceString(id));
904 const int prec = std::numeric_limits<float>::digits10 + 2;
905 std::string strValue = formatString("%.*g", prec, value);
906 std::string refStrValue =
907 impl_->processItem(Impl::cRealNodeName, id, strValue, &bFound);
911 float refValue = static_cast<float>(std::strtod(refStrValue.c_str(), &endptr));
912 EXPECT_EQ('\0', *endptr);
913 if (impl_->bSelfTestMode_)
915 EXPECT_FLOAT_EQ_TOL(refValue, value, impl_->defaultTolerance_)
916 << "String value: " << strValue << std::endl
917 << " Ref. string: " << refStrValue;
921 EXPECT_FLOAT_EQ_TOL(refValue, value, impl_->defaultTolerance_);
927 void TestReferenceChecker::checkReal(float value, const char *id)
929 checkFloat(value, id);
933 void TestReferenceChecker::checkReal(double value, const char *id)
935 checkDouble(value, id);
939 void TestReferenceChecker::checkVector(const int value[3], const char *id)
941 TestReferenceChecker compound(checkCompound(Impl::cVectorType, id));
942 compound.checkInteger(value[0], "X");
943 compound.checkInteger(value[1], "Y");
944 compound.checkInteger(value[2], "Z");
948 void TestReferenceChecker::checkVector(const float value[3], const char *id)
950 TestReferenceChecker compound(checkCompound(Impl::cVectorType, id));
951 compound.checkReal(value[0], "X");
952 compound.checkReal(value[1], "Y");
953 compound.checkReal(value[2], "Z");
957 void TestReferenceChecker::checkVector(const double value[3], const char *id)
959 TestReferenceChecker compound(checkCompound(Impl::cVectorType, id));
960 compound.checkReal(value[0], "X");
961 compound.checkReal(value[1], "Y");
962 compound.checkReal(value[2], "Z");
967 TestReferenceChecker::checkSequenceCompound(const char *id, size_t length)
969 TestReferenceChecker compound(checkCompound(Impl::cSequenceType, id));
970 compound.checkInteger(static_cast<int>(length), Impl::cSequenceLengthName);