Plum Hall, Inc.

Home  Products  News  ANSI/ISO 


LibSuite++®:
The Plum Hall Validation Suite for
The C++ Library

LibSuite++®, the Plum Hall Validation Suite for The C++ Library, is a set of C++ programs for testing and evaluating a C++ library implemenation. This overview will explain how each section of the Suite works. The examples will illustrate the use of LibSuite++.

TECHNICAL OVERVIEW

LibSuite++ covers Chapters 17 through 27 and Normative Annex D of ISO/IEC 14882:1998 (the ANSI/ISO Standard for C++) which was published by ISO and ANSI in September 1998.

Each test in the suite is derived from a specific statement in the Standard. Each statement is identified using a notation that Plum Hall calls "Section-Paragraph-Sentence" (SPS) notation. For example, 522Y91 denotes section 5.2.2, paragraph 9, sentence 1, in the "Y-th" (final) draft of the Standard. A leading underscore identifies a two-digit subsequence. For example,

SPS Section Paragraph Sentence
533Y1_11 5.3.3 1 11
533Y_102 5.3.3 10 2
5_17Y71 5.17 7 1

Many sentences have multiple test cases, distinguished by a lower case letter appended to the SPS designation, e.g., 46Y16a and 46Y16b. Here is how we designate "sentences":

  1. Full English sentences are easy: one sentence.
  2. Each line of a syntax production is one sentence; the defined non-terminal is taken as the left-hand-side of each production. For example:
    		cv-qualifier:
    		    const
    		    volatile
    
    is counted as if written like this:
    		cv-qualifier: const
    		cv-qualifier: volatile
    
  3. If an English sentence leads into a syntax rule, this is one sentence.
  4. If text preceeds the paragraph numbered "1", the text is taken as constituting paragraph number 0.
  5. In some cases, each different function signature is counted as one sentence.

The Plum Hall suites use these "section-paragraph-sentence" numbers to allow you to turn off particular tests during compilation. For example, if your compiler cannot compile case number 533Y1_11, you can "skip" this case by compiling with the "skip-flag" #define SKIP533Y1_11.

CONFORM

The subdirectories of the CONFORM section provide 80 C++ programs, each covering part of a clause in the Library section of the Working Paper:

        t170.cpp        Clause 17; 
        t180.cpp        First part of clause 18;
        t181.cpp        Second part of clause 18;
                        etc.

Each subdirectory, such as t170.DIR provides one large file, such as t170.cpp, which collects together all or most of the tests in its section. The subdirectory also provides individual files, t170c001.cpp, t170c002.cpp, each of which contain only one specific test case. Therefore, if your compiler and library are unable to successfully translate and execute all of the cases in the large file, you can compile and run the smaller files individually. Each subdirectory contains a build script that performs this logic automatically.

Each program writes a report to its .out file in a form very similar to the output of the LANG program in the C Suite. That is, t170 reports that it has executed the first test with the output

***** Reached first test *****

t170 reports errors using messages of the form

ERROR in t170 at line 656: (4) != (5)

and prints a summary of the form

***** 16 individual successful items in t170
***** 11 successful tests in t170
***** 0 errors detected in t170
***** 0 skipped sections in t170

An "individual successful item" is the successful outcome of one individual test function (ieq, chk, etc.). A "successful test" is the completion of a begin_case - end_case sequence with no errors in its individual items.

SELECTIVE ENABLING/DISABLING WITH flags.h

In the "destination root" directory, you should create a file named flags.h. This header is #included by each LibSuite++ file, so that you can record specific enable/disable flags for the tests being made in this directory tree.

If your C++ compiler cannot compile a particular test case, you can use a SKIP flag to disable that case. For example, to prevent compilation of test case _17312Y21 in t170.cpp, add

#define SKIP_17312Y21   because some reason

to the file flags.h. Then recompile and relink t170. The line,

#SKIPPED: _17312Y21 (>because some reason<)

will appear in the output when you execute t170. The total number of skipped cases appears at the end of the output.

You can also define DISALLOW flags in flags.h to globally disable certain language features that your compiler may not be able to handle. For example,

#define DISALLOW_MEMBER_TEMPLATES

compiles alternative code for some cases to accommodate the absence of member templates.

Some other DISALLOW flags are,

Controversial Cases

We strive to make LibSuite++ test the C++ language as commonly understood by the worldwide C++ community. The on-going purpose of the Standard is to capture that understanding. However, there will probably always be specific issues in the language which evoke differing interpretations, and hence there will be specific tests in LibSuite++ which evoke differing opinions from LibSuite++ users about the expected results. LibSuite++ accommodates controversial tests in the category of "disputed cases".

A "disputed case" is a test for which some LibSuite++ users have expressed the view that, although the test reflects the words in the Standard, the words in the Standard do not reflect common practice.

We hope to eventually resolve all the disputed cases and convert them to agreeable tests in the CONFORM sections of LibSuite++. We welcome your feedback regarding our judgements in these areas.

Running the CONFORM Programs

Once configuration is completed, you are ready to compile and execute the CONFORM programs. Any compile errors reported may represent currently-unimplemented syntactic features, or bugs in your compiler, or bugs in LibSuite++. Or, don't forget, sometimes a compile error means that the compiler wasn't properly installed, or that you weren't told the proper command-line options to use, or that the compilation environment wasn't properly set up. You have to investigate all these possibilities.

If you are unable to trace the cause of any compile errors whilst building CONFORM, you should telephone, fax or email Plum Hall for assistance.

Tracing

There is an extensive "trace" capability; Many of the routines in util.c (e.g., iequals) receive a line-number argument. Each of these routines will, if the global variable Debug is non-zero, print a diagnostic trace to the standard-error output. This trace keeps track of the source-file and line numbers of all statements reached. Each of the executable programs in CONFORM will set Debug to non-zero if the program is invoked with any command-line argument. Thus, to execute the t170 program with debug-tracing, you should execute:

        t170 debug

Tabulating a Summary of Results with summary

In the source root directory, there is a file called lvs.exp ("library validation suite, expected"), which lists the expected output file names and the number of successful execution cases for each expected output. The makefile in each destination root copies this expected-results file into the destination root. Thus, at any time during your work, you can cd into the destination root and run this command

summary -f lvs.exp

and you will receive a table of expected-versus-actual results, including an indication of "missing" output files (e.g. haven't been compiled yet, or "bombed out" prior to completion).

SAMPLER OF TEST CASES

There are twelve clauses in the Library section of the ISO/IEC 14882:1998: Clauses 17 through 27, and Normative Annex D. In the following "sampler" of cases, we present an example of one test case from each of the twelve clauses. The examples are chosen to be representative of the breadth and depth of the product.

Clause 17: Library introduction

#include "defs.h"

/* _17321T22 may be included more than once (except <assert.h>) */
#if (!defined(SKIP_17321T22)&&!defined(SKIP17)&&!defined(ONLY))||defined(CASE_17321T22)
#include <cstddef>
#include <cstddef>
#include <iostream>
#include <iostream>
#undef NDEBUG
#include <cassert>
static int fun1_17321T22() {assert(1); return (1); }
#define NDEBUG
#include <cassert>
static int fun2_17321T22() {assert(0); return (1); }
#undef NDEBUG
#include <cassert>
static int fun3_17321T22() {assert(1); return (1); }
#endif /* CASE_17321T22 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_17321T22");
	Filename = "t170c006.c";

/* _17321T22 may be included more than once (except <assert.h>) */
#if (!defined(SKIP_17321T22)&&!defined(SKIP17)&&!defined(ONLY))||defined(CASE_17321T22)
	begin_case("_17321T22");
	{
	ieq(fun1_17321T22(), 1);
	ieq(fun2_17321T22(), 1);
	ieq(fun3_17321T22(), 1);
	
	
	//E 17.3.3.1:
	//E A C++ program must be allowed to extend the namespace std if only
	//E to specialize class numeric_limits.
	
	}
	end_case("_17321T22" PH_STR( (>FAIL_17321T22<) ));
#else
	pr_skip("_17321T22" PH_STR( (>SKIP_17321T22<) ));
#endif /* CASE_17321T22 */

return report("_17321T22");
*}

Clause 18: Language support library

#include "defs.h"

/* _18211T21 radix, epsilon, and round_error meaningful for floating */
#if 
(!defined(SKIP_18211T21)&&!defined(SKIP18)&&!defined(ONLY))||defined(CASE_18211T21)
#include <cfloat>
#include <limits>
#endif /* CASE_18211T21 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_18211T21");
	Filename = "t180c007.c";

/* _18211T21 radix, epsilon, and round_error meaningful for floating */
#if (!defined(SKIP_18211T21)&&!defined(SKIP18)&&!defined(ONLY))||defined(CASE_18211T21)
	begin_case("_18211T21");
	{
	ieq(STD numeric_limits<float>::radix, FLT_RADIX);
	ieq(STD numeric_limits<double>::radix, FLT_RADIX);
	ieq(STD numeric_limits<long double>::radix, FLT_RADIX);
	chk(STD numeric_limits<float>::epsilon() == FLT_EPSILON);
	chk(STD numeric_limits<double>::epsilon() == DBL_EPSILON);
	chk(STD numeric_limits<long double>::epsilon() == LDBL_EPSILON);
	chk(0 < STD numeric_limits<float>::round_error());
	chk(0 < STD numeric_limits<double>::round_error());
	chk(0 < STD numeric_limits<long double>::round_error());
	
	
	//E 18.2.1.1:
	//E Paragraph 3 is repeated as 18.2.1.2, paragraph 50, where it belongs.
	//E Should be removed here.
	
	//E 18.2.1.1:
	//E Should say that numeric_limits<T> must be able to return T(0).
	//E Should say that round_style defaults to round_indeterminate,
	//E not round_toward_zero.
	
	}
	end_case("_18211T21" PH_STR( (>FAIL_18211T21<) ));
#else
	pr_skip("_18211T21" PH_STR( (>SKIP_18211T21<) ));
#endif /* CASE_18211T21 */

return report("_18211T21");
}

Clause 19: Diagnostics library

#include "defs.h"

/* _1911T_111 exception::what returns */
#if (!defined(SKIP_1911T_111)&&!defined(SKIP19)&&!defined(ONLY))||defined(CASE_1911T_111)
#include <cstring>
#include <stdexcept>
#endif /* CASE_1911T_111 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_1911T_111");
	Filename = "t190c006.c";

/* _1911T_111 exception::what returns */
#if (!defined(SKIP_1911T_111)&&!defined(SKIP19)&&!defined(ONLY))||defined(CASE_1911T_111)
	begin_case("_1911T_111");
	{
	STD exception x;
	const char *s = x.what();
	chk(s != 0 && 0 < STD strlen(s));
	
	}
	end_case("_1911T_111" PH_STR( (>FAIL_1911T_111<) ));
#else
	pr_skip("_1911T_111" PH_STR( (>SKIP_1911T_111<) ));
#endif /* CASE_1911T_111 */

return report("_1911T_111");
}

Clause 20: General utilities library

#include "defs.h"



/* _2021T41 operator<(T, T) returns */
#if (!defined(SKIP_2021T41)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2021T41)
#include <utility>
static int cnt_2021T41;
#endif /* CASE_2021T41 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_2021T41");
	Filename = "t200c003.c";

/* _2021T41 operator<(T, T) returns */
#if (!defined(SKIP_2021T41)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2021T41)
	begin_case("_2021T41");
	{
	class wrap {
	public:
		wrap(int val_arg)
			: value(val_arg) {}
		bool operator==(wrap arg) const
			{cnt_2021T41 += 1;
			return (val() == arg.val()); }
		bool operator<(wrap arg) const
			{cnt_2021T41 += 10;
			return (val() < arg.val()); }
		int val() const
			{return (value); }
	private:
		int value;
		};
	wrap x(3), y(5);
	cnt_2021T41 = 0;
	chk(y > x);
	ieq(cnt_2021T41, 10);
	
	
	}
	end_case("_2021T41" PH_STR( (>FAIL_2021T41<) ));
#else
	pr_skip("_2021T41" PH_STR( (>SKIP_2021T41<) ));
#endif /* CASE_2021T41 */

return report("_2021T41");
}

Clause 21: Strings library

#include "defs.h"

/* _2112T91 string_char_traits::lt returns */
#if (!defined(SKIP_2112T91)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2112T91)
#include <string>
#endif /* CASE_2112T91 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_2112T91");
	Filename = "t210c006.c";

/* _2112T91 string_char_traits::lt returns */
#if (!defined(SKIP_2112T91)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2112T91)
	begin_case("_2112T91");
	{
	typedef STD string_char_traits<Char> Strt;
	Char x1 = 0, x2 = 3;
	chk(Strt::lt(x1, x2));
	chk(!Strt::lt(x1, x1));
	
	
	//E 21.1.1.2:
	//E string_char_traits::eos should not be required to return the
	//E result of the default constructor char_type() (when specialized).
	//E Either the specific requirement should be relaxed or the function
	//E should be eliminated.
	
	}
	end_case("_2112T91" PH_STR( (>FAIL_2112T91<) ));
#else
	pr_skip("_2112T91" PH_STR( (>SKIP_2112T91<) ));
#endif /* CASE_2112T91 */

return report("_2112T91");
}

Clause 22: Localization library

#include "defs.h"

/* _221111T11 locale::category valid values */
#if (!defined(SKIP_221111T11)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_221111T11)
#include <locale>
#endif /* CASE_221111T11 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_221111T11");
	Filename = "t220c003.c";

/* _221111T11 locale::category valid values */
#if (!defined(SKIP_221111T11)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_221111T11)
	begin_case("_221111T11");
	{
	locale::category cats[] = {(locale::category)0, locale::none,
		locale::collate, locale::ctype,
		locale::monetary, locale::numeric,
		locale::time, locale::messages};
	chk(1);
	
	}
	end_case("_221111T11" PH_STR( (>FAIL_221111T11<) ));
#else
	pr_skip("_221111T11" PH_STR( (>SKIP_221111T11<) ));
#endif /* CASE_221111T11 */

return report("_221111T11");
}

Clause 23: Containers library

#include "defs.h"

/* _232T61 <vector> synopsis */
#if (!defined(SKIP_232T61)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_232T61)
#include <vector>
#endif /* CASE_232T61 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_232T61");
	Filename = "t230c006.c";

/* _232T61 <vector> synopsis */
#if (!defined(SKIP_232T61)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_232T61)
	begin_case("_232T61");
	{
	typedef vector<Char, ALLOCATOR(Char)> Cont;
	Cont v0;
	chk(v0 == v0);
	chk(!(v0 < v0));
	typedef vector<bool, ALLOCATOR(bool)> Bvec;
	Bvec v1;
	chk(v1 == v1);
	chk(!(v1 < v1));
	
	}
	end_case("_232T61" PH_STR( (>FAIL_232T61<) ));
#else
	pr_skip("_232T61" PH_STR( (>SKIP_232T61<) ));
#endif /* CASE_232T61 */

return report("_232T61");
}

Clause 24: Iterators library

#include "defs.h"

/* _2416T_111 <iterator> synopsis */
#if (!defined(SKIP_2416T_111)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2416T_111)
#include <deque>
#include <iterator>
#include <sstream>
#endif /* CASE_2416T_111 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_2416T_111");
	Filename = "t240c001.c";

/* _2416T_111 <iterator> synopsis */
#if (!defined(SKIP_2416T_111)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2416T_111)
	begin_case("_2416T_111");
	{
	output_iterator_tag *ptag0;
	input_iterator_tag *ptag1;
	forward_iterator_tag *ptag2;
	bidirectional_iterator_tag *ptag3;
	random_access_iterator_tag *ptag4;
	
	output_iterator *piter0;
	input_iterator<int, double> *piter1;
	forward_iterator<int, double> *piter2;
	bidirectional_iterator<int, double> *piter3;
	random_access_iterator<int, double> *piter4;
	
	istringstream is0;
	ostringstream os0;
	istream_iterator<int, double> iter5(is0);
	ostream_iterator<int> iter6(os0);
	istreambuf_iterator<char, ios_traits<char> > iter7;
	ostreambuf_iterator<char, ios_traits<char> > iter8;
	chk(iter5 == iter5);
	chk(iter7 == iter7);
	
	reverse_iterator<int *, int, int&, long> rev0;
	reverse_bidirectional_iterator<int *, int, int&, long> rev1;
	
	typedef deque<int, ALLOCATOR(int)> Cont;
	Cont d0;
	back_insert_iterator<Cont> conit0(back_inserter(d0));
	front_insert_iterator<Cont> conit1(front_inserter(d0));
	insert_iterator<Cont> conit2(inserter(d0, d0.begin()));
	
	output_iterator_tag tag0 = iterator_category(*piter0);
	int *pi = value_type(*piter1);
	double *pd = distance_type(*piter2);
	
	chk(rev0 == rev0);
	if (rev0 < rev0)
		{long d1 = rev0 - rev0;	// shouldn't execute
		rev0 = d1 + rev0;
		advance(rev0, d1);
		distance(rev0, rev0, d1); }
	chk(rev1 == rev1);
	}
	end_case("_2416T_111" PH_STR( (>FAIL_2416T_111<) ));
#else
	pr_skip("_2416T_111" PH_STR( (>SKIP_2416T_111<) ));
#endif /* CASE_2416T_111 */
return report("_2416T_111");
}

Clause 25: Algorithms library

#include "defs.h"
#include <algorithm>

/* _2515T31a adjacent_find(-) effects, returns, complexity */
#if (!defined(SKIP_2515T31a)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2515T31a)
#include <algorithm>
#include <string>
#include <cstring>
#include "iter.h"
#endif /* CASE_2515T31a */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_2515T31a");
	Filename = "t251c008.c";

/* _2515T31a adjacent_find(-) effects, returns, complexity */
#if (!defined(SKIP_2515T31a)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2515T31a)
	begin_case("_2515T31a");
	{
	// simple pointers
	Char buf[] = "abb";
	Char *p1 = buf;
	Char *p2 = buf+3;
	Char *p3;
	p3 = adjacent_find(p1, p1);
	aeq(p3, p1);
	p3 = adjacent_find(p1, p1 + 1);
	aeq(p3, p1 + 1);
	p3 = adjacent_find(p1, p2);
	aeq(p3, buf+1);
	ieq(*p3, 'b');
	p3 = adjacent_find(p1, p2 - 1);  // no repeated instance
	aeq(p3, p2 - 1);
	ieq(*p3, 'b');
	
	// strings
	string s ("xbb");
	ieq(*adjacent_find(s.begin(), s.end()), 'b');
	
	// strict iterators over strings
	typedef STD basic_string<Char,
		STD string_char_traits<Char>,
		ALLOCATOR(Char)> Ustr;
	ALLOCATOR(Char) al;
	const Char *buf2 = (const Char *)"xbbcd";
	Ustr s4 (buf2, buf2+4);
	int err1 = 0, nrec1 = 4;
	strict_forward_iterator<Ustr::iterator, Char> it1
		(s4.begin(), err1, nrec1);
	int err2 = 0, nrec2 = 0;
	strict_forward_iterator<Ustr::iterator, Char> it2
		(s4.end(), err2, nrec2);
	strict_forward_iterator<Ustr::iterator, Char> it 
		(adjacent_find(it1, it2));
	ieq(*it, 'b');
	ieq(*++it, 'b');
	ieq(*++it, 'c');
	ieq(err1, 0);
	ieq(err2, 0);
	}
	end_case("_2515T31a" PH_STR( (>FAIL_2515T31a<) ));
#else
	pr_skip("_2515T31a" PH_STR( (>SKIP_2515T31a<) ));
#endif /* CASE_2515T31a */
return report("_2515T31a");
}

Clause 26: Numerics library

#include "defs.h"
#include <complex>

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_2624T21");
	Filename = "t260c003.c";

/* _2624T21 operator-=   effects, returns */
#if (!defined(SKIP_2624T21)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_2624T21)
	begin_case("_2624T21");
	{
		complex<float> cf (9., 8.);
		complex<float> cf2 (7., 5.);
		feq((cf -= cf2).real(), 2.);
		feq(cf.real(), 2.);
		feq(cf.imag(), 3.);
	
		complex<double> cd (9., 8.);
		complex<double> cd2 (7., 5.);
		deq((cd -= cd2).real(), 2.);
		deq(cd.real(), 2.);
		deq(cd.imag(), 3.);
	
		complex<long double> cld (9., 8.);
		complex<long double> cld2 (7., 5.);
		ldeq((cld -= cld2).real(), 2.);
		ldeq(cld.real(), 2.);
		ldeq(cld.imag(), 3.);
	
		complex<int> ci (9, 8);
		complex<int> ci2 (7, 5);
		ieq((ci -= ci2).real(), 2);
		ieq(ci.real(), 2);
		ieq(ci.imag(), 3);
	
	}
	end_case("_2624T21" PH_STR( (>FAIL_2624T21<) ));
#else
	pr_skip("_2624T21" PH_STR( (>SKIP_2624T21<) ));
#endif /* CASE_2624T21 */

return report("_2624T21");
}

Clause 27: Input/output library

#include "defs.h"

/* _273T32 <iostream> objects constructed by basic_ios::Init */
#if (!defined(SKIP_273T32)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_273T32)
#include <iostream>
int cnt_273T32 = 0;
STD basic_ios<wchar_t, STD ios_traits<wchar_t> >::Init x2;
struct x_273T32 {
	x_273T32()
		{if (STD cin.tie() == &STD cout)
			++cnt_273T32; }
	} staticx_273T32;
#endif /* CASE_273T32 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_273T32");
	Filename = "t270c003.c";

/* _273T32 <iostream> objects constructed by basic_ios::Init */
#if (!defined(SKIP_273T32)&&!defined(SKIP2)&&!defined(ONLY))||defined(CASE_273T32)
	begin_case("_273T32");
	{
	ieq(cnt_273T32, 1);
	chk(STD cin);
	chk(STD win);
	}
	end_case("_273T32" PH_STR( (>FAIL_273T32<) ));
#else
	pr_skip("_273T32" PH_STR( (>SKIP_273T32<) ));
#endif /* CASE_273T32 */

return report("_273T32");
}

Annex D: Compatibility features

#include "defs.h"

/* _XD2T11 ios_base defines io_state, open_mode, seek_dir */
#if (!defined(SKIP_XD2T11)&&!defined(SKIPX)&&!defined(ONLY))||defined(CASE_XD2T11)
#include <ios>
#endif /* CASE_XD2T11 */

int main(int argc, char *argv[])
{
	if (argc > 1 && argv[1] != 0)
		Debug = TRUE;
	ENTRY("_XD2T11");
	Filename = "txd0c003.c";

/* _XD2T11 ios_base defines io_state, open_mode, seek_dir */
#if (!defined(SKIP_XD2T11)&&!defined(SKIPX)&&!defined(ONLY))||defined(CASE_XD2T11)
	begin_case("_XD2T11");
	{
	ios_base::io_state s1 = ios_base::failbit;
	ios_base::open_mode s2 = ios_base::trunc;
	ios_base::seek_dir s3 = ios_base::cur;
	chk(1);
	
	
	}
	end_case("_XD2T11" PH_STR( (>FAIL_XD2T11<) ));
#else
	pr_skip("_XD2T11" PH_STR( (>SKIP_XD2T11<) ));
#endif /* CASE_XD2T11 */

return report("_XD2T11");
}


Contact Us for Product Information.

Plum Hall® Suite++® LibSuite++® Suite#® and JVS®are registered trademarks of Plum Hall, Inc.
CV-Suite™ and The Plum Hall Validation Suite for C™ are trademarks of Plum Hall, Inc.
Java™ is a trademark of Sun Microsystems, Inc.