feedc0de/boost_static_assert
1
0
Fork 0
forked from boostorg/static_assert
Code Pull Requests Activity

Static assert initial checkin

Browse Source 
[SVN r8381]
This commit is contained in:
John Maddock
2000-12-03 12:29:42 +00:00
commit 8cb6da5df0
16 changed files with 937 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
.gitattributes vendored Normal file
View File

@ -0,0 +1,96 @@
* text=auto !eol svneol=native#text/plain
*.gitattributes text svneol=native#text/plain
# Scriptish formats
*.bat text svneol=native#text/plain
*.bsh text svneol=native#text/x-beanshell
*.cgi text svneol=native#text/plain
*.cmd text svneol=native#text/plain
*.js text svneol=native#text/javascript
*.php text svneol=native#text/x-php
*.pl text svneol=native#text/x-perl
*.pm text svneol=native#text/x-perl
*.py text svneol=native#text/x-python
*.sh eol=lf svneol=LF#text/x-sh
configure eol=lf svneol=LF#text/x-sh
# Image formats
*.bmp binary svneol=unset#image/bmp
*.gif binary svneol=unset#image/gif
*.ico binary svneol=unset#image/ico
*.jpeg binary svneol=unset#image/jpeg
*.jpg binary svneol=unset#image/jpeg
*.png binary svneol=unset#image/png
*.tif binary svneol=unset#image/tiff
*.tiff binary svneol=unset#image/tiff
*.svg text svneol=native#image/svg%2Bxml
# Data formats
*.pdf binary svneol=unset#application/pdf
*.avi binary svneol=unset#video/avi
*.doc binary svneol=unset#application/msword
*.dsp text svneol=crlf#text/plain
*.dsw text svneol=crlf#text/plain
*.eps binary svneol=unset#application/postscript
*.gz binary svneol=unset#application/gzip
*.mov binary svneol=unset#video/quicktime
*.mp3 binary svneol=unset#audio/mpeg
*.ppt binary svneol=unset#application/vnd.ms-powerpoint
*.ps binary svneol=unset#application/postscript
*.psd binary svneol=unset#application/photoshop
*.rdf binary svneol=unset#text/rdf
*.rss text svneol=unset#text/xml
*.rtf binary svneol=unset#text/rtf
*.sln text svneol=native#text/plain
*.swf binary svneol=unset#application/x-shockwave-flash
*.tgz binary svneol=unset#application/gzip
*.vcproj text svneol=native#text/xml
*.vcxproj text svneol=native#text/xml
*.vsprops text svneol=native#text/xml
*.wav binary svneol=unset#audio/wav
*.xls binary svneol=unset#application/vnd.ms-excel
*.zip binary svneol=unset#application/zip
# Text formats
.htaccess text svneol=native#text/plain
*.bbk text svneol=native#text/xml
*.cmake text svneol=native#text/plain
*.css text svneol=native#text/css
*.dtd text svneol=native#text/xml
*.htm text svneol=native#text/html
*.html text svneol=native#text/html
*.ini text svneol=native#text/plain
*.log text svneol=native#text/plain
*.mak text svneol=native#text/plain
*.qbk text svneol=native#text/plain
*.rst text svneol=native#text/plain
*.sql text svneol=native#text/x-sql
*.txt text svneol=native#text/plain
*.xhtml text svneol=native#text/xhtml%2Bxml
*.xml text svneol=native#text/xml
*.xsd text svneol=native#text/xml
*.xsl text svneol=native#text/xml
*.xslt text svneol=native#text/xml
*.xul text svneol=native#text/xul
*.yml text svneol=native#text/plain
boost-no-inspect text svneol=native#text/plain
CHANGES text svneol=native#text/plain
COPYING text svneol=native#text/plain
INSTALL text svneol=native#text/plain
Jamfile text svneol=native#text/plain
Jamroot text svneol=native#text/plain
Jamfile.v2 text svneol=native#text/plain
Jamrules text svneol=native#text/plain
Makefile* text svneol=native#text/plain
README text svneol=native#text/plain
TODO text svneol=native#text/plain
# Code formats
*.c text svneol=native#text/plain
*.cpp text svneol=native#text/plain
*.h text svneol=native#text/plain
*.hpp text svneol=native#text/plain
*.ipp text svneol=native#text/plain
*.tpp text svneol=native#text/plain
*.jam text svneol=native#text/plain
*.java text svneol=native#text/plain

89
include/boost/static_assert.hpp Normal file
View File

@ -0,0 +1,89 @@
// (C) Copyright John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
/*
Revision history:
02 August 2000
Initial version.
*/
#ifndef BOOST_STATIC_ASSERT_HPP
#define BOOST_STATIC_ASSERT_HPP
#include <boost/config.hpp>
#ifdef __BORLANDC__
//
// workaround for buggy integral-constant expression support:
#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS
#endif
namespace boost{
template <bool> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true>{};
template<int> struct static_assert_test{};
}
//
// Implicit instantiation requires that all member declarations be
// instantiated, but that the definitions are *not* instantiated.
//
// It's not particularly clear how this applies to enum's or typedefs;
// both are described as declarations [7.1.3] and [7.2] in the standard,
// however some compilers use "delayed evaluation" of one or more of
// these when implicitly instantiating templates. We use typedef declarations
// by default, but try defining BOOST_USE_ENUM_STATIC_ASSERT if the enum
// version gets better results from your compiler...
//
// Implementation:
// Both of these versions rely on sizeof(incomplete_type) generating an error
// message containing the name of the incomplete type. We use
// "STATIC_ASSERTION_FAILURE" as the type name here to generate
// an eye catching error message. The result of the sizeof expression is either
// used as an enum initialiser, or as a template argument depending which version
// is in use...
//
#ifndef BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS
#ifndef BOOST_MSVC
#define BOOST_STATIC_ASSERT( B ) \
typedef ::boost::static_assert_test<\
sizeof(::boost::STATIC_ASSERTION_FAILURE< ( B ) >)>\
BOOST_ASSERT_JOIN(boost_static_assert_typedef_, __LINE__)
#else
// __LINE__ macro broken when -ZI is used see Q199057
// fortunately MSVC ignores duplicate typedef's:
#define BOOST_STATIC_ASSERT( B ) \
typedef ::boost::static_assert_test<\
sizeof(::boost::STATIC_ASSERTION_FAILURE< ( B ) >)\
> boost_static_assert_typedef_
#endif
#else
// alternative enum based implementation:
#define BOOST_STATIC_ASSERT( B ) \
enum { BOOST_ASSERT_JOIN(boost_static_assert_enum_, __LINE__) \
= sizeof(::boost::STATIC_ASSERTION_FAILURE< ( B ) >) }
#endif
//
// The following piece of macro magic joins the two
// arguments together, even when one of the arguments is
// itself a macro (see 16.3.1 in C++ standard). The key
// is that macro expantion of macro arguments does not
// occur in BOOST_DO_ASSERT_JOIN but does in BOOST_ASSERT_JOIN
// provided it is called from within another macro.
#define BOOST_ASSERT_JOIN( X, Y ) BOOST_DO_ASSERT_JOIN( X, Y )
#define BOOST_DO_ASSERT_JOIN( X, Y ) X##Y
#endif // BOOST_STATIC_ASSERT_HPP

252
static_assert.htm Normal file
View File

@ -0,0 +1,252 @@
<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 5.0::19981217::extensions to HTML 4.0//EN" "hmpro5.dtd">
<HTML>
<HEAD>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<META NAME="Template"
CONTENT="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
<META NAME="GENERATOR" CONTENT="Microsoft FrontPage Express 2.0">
<TITLE>static assertions</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080">
<H1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86">Header &lt;<A
HREF="../../boost/detail/call_traits.hpp">boost/static_assert.hpp</A>&gt;</H1>
<P>The header &lt;boost/static_assert.hpp&gt; supplies a single macro
BOOST_STATIC_ASSERT(x), which generates a compile time error message if the
integral-constant-expression <I>x</I> is not true. In other words it is the
compile time equivalent of the assert macro; this is sometimes known as a
&quot;compile-time-assertion&quot;, but will be called a &quot;static
assertion&quot; throughout these docs. Note that if the condition is true, then
the macro will generate neither code nor data - and the macro can also be used
at either namespace, class or function scope. When used in a template, the
static assertion will be evaluated at the time the template is instantiated;
this is particularly useful for validating template parameters. </P>
<P>One of the aims of BOOST_STATIC_ASSERT is to generate readable error
messages. These immediately tell the user that a library is being used in a
manner that is not supported. While error messages obviously differ from
compiler to compiler, but you should see something like: </P>
<PRE>Illegal use of COMPILE_TIME_ASSERTION_FAILURE&lt;false&gt;</PRE>
<P>Which is intended to at least catch the eye!</P>
<P>You can use BOOST_STATIC_ASSERT at any place where you can place a
declaration, that is at <A HREF="#class">class</A>, <A
HREF="#function">function</A> or <A HREF="#namespace">namespace</A> scope, this
is illustrated by the following examples:</P>
<H3><A NAME="namespace"></A>Use at namespace scope.</H3>
<P>The macro can be used at namespace scope, if there is some requirement must
always be true; generally this means some platform specific requirement.
Suppose we require that <B>int</B> be at least a 32-bit integral type, and that
<B>wchar_t</B> be an unsigned type. We can verify this at compile time as
follows:</P>
<PRE>#include &lt;climits&gt;
#include &lt;cwchar&gt;
#include &lt;boost/static_assert.hpp&gt;
namespace my_conditions {
BOOST_STATIC_ASSERT(sizeof(int) * CHAR_BIT &gt;= 32);
BOOST_STATIC_ASSERT(WCHAR_MIN &gt;= 0);
} // namespace my_conditions
</PRE>
<P>The use of the namespace <I>my_conditions</I> here requires some comment.
The macro BOOST_STATIC_ASSERT works by generating an <STRONG>typedef</STRONG>
declaration, and since the typedef must have a name, the macro generates one
automatically by mangling a stub name with the value of __LINE__. When
BOOST_STATIC_ASSERT is used at either class or function scope then each use of
BOOST_STATIC_ASSERT is guaranteed to produce a name unique to that scope
(provided you only use the macro once on each line). However when used in a
header at namespace scope, that namespace can be continued over multiple
headers, each of which may have their own static assertions, and on the
&quot;same&quot; lines, thereby generating duplicate declarations. In theory
the compiler should silently ignore duplicate typedef declarations, however
many do not do so (and even if they do they are entitled to emit warnings in
such cases). To avoid potential problems, if you use BOOST_STATIC_ASSERT in a
header and at namespace scope, then enclose them in a namespace unique to that
header.</P>
<H3><A NAME="function"></A>Use at function scope</H3>
<P>The macro is typically used at function scope inside template functions,
when the template arguments need checking. Imagine that we have an
iterator-based algorithm that requires random access iterators. If the
algorithm is instantiated with iterators that do not meet our requirements then
an error will be generated eventually, but this may be nested deep inside
several templates, making it hard for the user to determine what went wrong.
One option is to add a static assertion at the top level of the template, in
that case if the condition is not met, then an error will be generated in a way
that makes it reasonably obvious to the user that the template is being
misused.</P>
<PRE>#include &lt;iterator&gt;
#include &lt;boost/static_assert.hpp&gt;
#include &lt;boost/type_traits.hpp&gt;
template &lt;class RandomAccessIterator &gt;
RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator to)
{
// this template can only be used with
// random access iterators...
typedef typename std::iterator_traits&lt; RandomAccessIterator &gt;::iterator_category cat;
BOOST_STATIC_ASSERT((boost::is_convertible&lt;cat, const std::random_access_iterator_tag&amp;&gt;::value));
//
// detail goes here...
return from;
}</PRE>
<P>A couple of footnotes are in order here: the extra set of parenthesis around
the assert, is to prevent the comma inside the is_convertible template being
interpreted by the preprocessor as a macro argument separator; the target type
for is_convertible is a reference type, as some compilers have problems using
is_convertible when the conversion is via a user defined constructor (in any
case there is no guarantee that the iterator tag classes are
copy-constructible).</P>
<H3><A NAME="class"></A>Use at class scope</H3>
<P>The macro is typically used inside classes that are templates. Suppose we
have a template-class that requires an unsigned integral type with at least
16-bits of precision as a template argument, we can achieve this using
something like this:</P>
<PRE>#include &lt;climits&gt;
#include &lt;boost/static_assert.hpp&gt;
Template &lt;class UnsignedInt&gt;template &lt;class UnsignedInt&gt;
class myclass
{
private:
BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT &gt;= 16);
BOOST_STATIC_ASSERT(std::numeric_limits&lt;UnsignedInt&gt;::is_specialized
&amp;&amp; std::numeric_limits&lt;UnsignedInt&gt;::is_integer
&amp;&amp; !std::numeric_limits&lt;UnsignedInt&gt;::is_signed);
public:
/* details here */
};
</PRE>
<H3>How it works</H3>
<P>BOOST_STATIC_ASSERT works as follows. There is class
STATIC_ASSERTION_FAILURE which is defined as:</P>
<PRE>namespace boost{
template &lt;bool&gt; struct STATIC_ASSERTION_FAILURE;
template &lt;&gt; struct STATIC_ASSERTION_FAILURE&lt;true&gt;{};
}</PRE>
<P>The key feature is that the error message triggered by the undefined
expression sizeof(STATIC_ASSERTION_FAILURE&lt;0&gt;), tends to be consistent
across a wide variety of compilers. The rest of the machinery of
BOOST_STATIC_ASSERT is just a way to feed the sizeof expression into a typedef.
The use of a macro here is somewhat ugly; however boost members have spent
considerable effort trying to invent a static assert that avoided macros, all
to no avail. The general conclusion was that the good of a static assert
working at namespace, function, and class scope outweighed the ugliness of a
macro.</P>
<H3>Test Programs</H3>
<P>The following test programs are provided with this library:</P>
<TABLE BORDER="0" WIDTH="100%">
<TR>
<TD WIDTH="33%"><I>Test Program</I></TD>
<TD WIDTH="33%"><I>Expected to Compile</I></TD>
<TD WIDTH="34%"><I>Description</I></TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test.cpp">static_assert_test.cpp</A></TD>
<TD WIDTH="33%">Yes</TD>
<TD WIDTH="34%">Illustrates usage, and should always compile, really just tests
compiler compatibility.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_example_1.cpp">static_assert_example_1.cpp</A></TD>
<TD WIDTH="33%">Platform dependent.</TD>
<TD WIDTH="34%">Namespace scope test program, may compile depending upon the
platform.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_example_2.cpp">static_assert_example_2.cpp</A></TD>
<TD WIDTH="33%">Yes</TD>
<TD WIDTH="34%">Function scope test program.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_example_3.cpp">static_assert_example_3.cpp</A></TD>
<TD WIDTH="33%">Yes</TD>
<TD WIDTH="34%">Class scope test program.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test_fail_1.cpp">static_assert_test_fail_1.cpp</A></TD>
<TD WIDTH="33%">No</TD>
<TD WIDTH="34%">Illustrates failure at namespace scope.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test_fail_2.cpp">static_assert_test_fail_2.cpp</A></TD>
<TD WIDTH="33%">No</TD>
<TD WIDTH="34%">Illustrates failure at non-template function scope.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test_fail_3.cpp">static_assert_test_fail_3.cpp</A></TD>
<TD WIDTH="33%">No</TD>
<TD WIDTH="34%">Illustrates failure at non-template class scope.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test_fail_4.cpp">static_assert_test_fail_4.cpp</A></TD>
<TD WIDTH="33%">No</TD>
<TD WIDTH="34%">Illustrates failure at non-template class scope.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test_fail_5.cpp">static_assert_test_fail_5.cpp</A></TD>
<TD WIDTH="33%">No</TD>
<TD WIDTH="34%">Illustrates failure at template class scope.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test_fail_6.cpp">static_assert_test_fail_6.cpp</A></TD>
<TD WIDTH="33%">No</TD>
<TD WIDTH="34%">Illustrates failure at template class member function
scope.</TD>
</TR>
<TR>
<TD WIDTH="33%"><A
HREF="static_assert_test_fail_7.cpp">static_assert_test_fail_7.cpp</A></TD>
<TD WIDTH="33%">No</TD>
<TD WIDTH="34%">Illustrates failure of class scope example.</TD>
</TR>
<TR>
<TD><A
HREF="static_assert_test_fail_8.cpp">static_assert_test_fail_8.cpp</A></TD>
<TD>No</TD>
<TD>Illustrates failure of function scope example.</TD>
</TR>
<TR>
<TD><A
HREF="static_assert_test_fail_9.cpp">static_assert_test_fail_9.cpp</A></TD>
<TD>No</TD>
<TD>Illustrates failure of function scope example (part 2).</TD>
</TR>
</TABLE>
<HR>
<P>Revised 27th Nov 2000</P>
<P>Documentation &copy; Copyright John Maddock 2000. Permission to copy, use,
modify, sell and distribute this document is granted provided this copyright
notice appears in all copies. This document is provided &quot;as is&quot;
without express or implied warranty, and with no claim as to its suitability
for any purpose.</P>
<P>Based on contributions by Steve Cleary and John Maddock.</P>
<P>Maintained by <A HREF="mailto:John_Maddock@compuserve.com">John Maddock</A>,
the latest version of this file can be found at <A
HREF="http://www.boost.org/">www.boost.org</A>, and the boost discussion list
at <A HREF="http://www.egroups.com/list/boost">www.egroups.com/list/boost</A>.
</P>
<P>&nbsp;</P>
<P>&nbsp;</P>
</BODY>
</HTML>

31
static_assert_example_1.cpp Normal file
View File

@ -0,0 +1,31 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <climits>
#include <cwchar>
#include <boost/static_assert.hpp>
#if defined(__BORLANDC__) && !defined(WCHAR_MIN)
#define WCHAR_MIN 0
#endif
namespace boost{
namespace my_conditions {
BOOST_STATIC_ASSERT(sizeof(int) * CHAR_BIT >= 32);
BOOST_STATIC_ASSERT(WCHAR_MIN >= 0);
} // namespace my_conditions
} // namespace boost
int main()
{
return 0;
}

40
static_assert_example_2.cpp Normal file
View File

@ -0,0 +1,40 @@
// (C) Copyright John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <iterator>
#include <list>
#include <deque>
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
template <class RandomAccessIterator >
RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator to)
{
// this template can only be used with
// random access iterators...
typedef typename std::iterator_traits< RandomAccessIterator >::iterator_category cat;
BOOST_STATIC_ASSERT((boost::is_convertible<cat, const std::random_access_iterator_tag&>::value));
//
// detail goes here...
return from;
}
int main()
{
std::deque<int> d;
std::list<int> l;
foo(d.begin(), d.end()); // OK
//foo(l.begin(), l.end()); // error
return 0;
}

32
static_assert_example_3.cpp Normal file
View File

@ -0,0 +1,32 @@
// (C) Copyright John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <climits>
#include <limits>
#include <boost/static_assert.hpp>
template <class UnsignedInt>
class myclass
{
private:
BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
&& std::numeric_limits<UnsignedInt>::is_integer
&& !std::numeric_limits<UnsignedInt>::is_signed);
public:
/* details here */
};
myclass<unsigned> m1; // this should be OK
//myclass<int> m2; // this should fail
//myclass<unsigned char> m3; // and so should this
int main()
{
return 0;
}

88
static_assert_test.cpp Normal file
View File

@ -0,0 +1,88 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <boost/static_assert.hpp>
//
// all these tests should succeed.
// some of these tests are rather simplistic (ie useless)
// in order to ensure that they compile on all platforms.
//
// Namespace scope
BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
BOOST_STATIC_ASSERT(sizeof(char) == 1);
// Function (block) scope
void f()
{
BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
BOOST_STATIC_ASSERT(sizeof(char) == 1);
}
struct Bob
{
private: // can be in private, to avoid namespace pollution
BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
BOOST_STATIC_ASSERT(sizeof(char) == 1);
public:
// Member function scope: provides access to member variables
int x;
char c;
int f()
{
#ifndef _MSC_VER // broken sizeof in VC6
BOOST_STATIC_ASSERT(sizeof(x) >= sizeof(short));
BOOST_STATIC_ASSERT(sizeof(c) == 1);
#endif
return x;
}
};
// Template class scope
template <class Int, class Char>
struct Bill
{
private: // can be in private, to avoid namespace pollution
BOOST_STATIC_ASSERT(sizeof(Int) > sizeof(char));
public:
// Template member function scope: provides access to member variables
Int x;
Char c;
template <class Int2, class Char2>
void f(Int2 , Char2 )
{
BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
}
};
void test_Bill() // BOOST_CT_ASSERTs are not triggerred until instantiated
{
Bill<int, char> z;
//Bill<int, int> bad; // will not compile
int i = 3;
char ch = 'a';
z.f(i, ch);
//z.f(i, i); // should not compile
}
int main()
{
test_Bill();
return 0;
}

21
static_assert_test_fail_1.cpp Normal file
View File

@ -0,0 +1,21 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <boost/static_assert.hpp>
//
// all these tests should fail:
//
// Namespace scope
BOOST_STATIC_ASSERT(sizeof(int) == sizeof(char)); // will not compile

23
static_assert_test_fail_2.cpp Normal file
View File

@ -0,0 +1,23 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <boost/static_assert.hpp>
//
// all these tests should fail:
//
// Function (block) scope
void f()
{
BOOST_STATIC_ASSERT(sizeof(int) == sizeof(char)); // should not compile
}

38
static_assert_test_fail_3.cpp Normal file
View File

@ -0,0 +1,38 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <boost/static_assert.hpp>
//
// this tests should fail:
//
struct Bob
{
private: // can be in private, to avoid namespace pollution
BOOST_STATIC_ASSERT(sizeof(int) == sizeof(char)); // will not compile
public:
// Member function scope: provides access to member variables
int x;
char c;
int f()
{
#ifndef _MSC_VER // broken sizeof in VC6
BOOST_STATIC_ASSERT(sizeof(x) == 4);
BOOST_STATIC_ASSERT(sizeof(c) == 1);
#endif
//BOOST_STATIC_ASSERT((sizeof(x) == sizeof(c))); // should not compile
return x;
}
};

42
static_assert_test_fail_4.cpp Normal file
View File

@ -0,0 +1,42 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
//
// all these tests should fail:
//
#ifdef BOOST_MSVC
#error "VC6 not supported in this test (buggy compiler problem)"
#endif
struct Bob
{
public:
// Member function scope: provides access to member variables
int x;
char c;
int f()
{
#ifndef _MSC_VER // broken sizeof in VC6
BOOST_STATIC_ASSERT(sizeof(x) == 4);
BOOST_STATIC_ASSERT(sizeof(c) == 1);
BOOST_STATIC_ASSERT((sizeof(x) == sizeof(c))); // should not compile
#endif
return x;
}
};

39
static_assert_test_fail_5.cpp Normal file
View File

@ -0,0 +1,39 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <boost/static_assert.hpp>
//
// all these tests should fail:
//
// Template class scope
template <class Int, class Char>
struct Bill
{
private: // can be in private, to avoid namespace pollution
BOOST_STATIC_ASSERT(sizeof(Int) == 4);
BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
public:
// Template member function scope: provides access to member variables
Int x;
Char c;
template <class Int2, class Char2>
void f(Int2 , Char2 )
{
BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
//BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
}
};
Bill<int, char> b;

46
static_assert_test_fail_6.cpp Normal file
View File

@ -0,0 +1,46 @@
// (C) Copyright Steve Cleary & John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <boost/static_assert.hpp>
//
// all these tests should fail:
//
// Template class scope
template <class Int, class Char>
struct Bill
{
private: // can be in private, to avoid namespace pollution
BOOST_STATIC_ASSERT(sizeof(Int) == 4);
//BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
public:
// Template member function scope: provides access to member variables
Int x;
Char c;
template <class Int2, class Char2>
void f(Int2 , Char2 )
{
BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
}
};
void foo()
{
int i = 0;
char c = 0;
Bill<int, char> b;
// this should fail:
b.f(i, c);
}

31
static_assert_test_fail_7.cpp Normal file
View File

@ -0,0 +1,31 @@
// (C) Copyright John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <climits>
#include <limits>
#include <boost/static_assert.hpp>
template <class UnsignedInt>
class myclass
{
private:
BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
&& std::numeric_limits<UnsignedInt>::is_integer
&& !std::numeric_limits<UnsignedInt>::is_signed);
public:
/* details here */
};
myclass<int> m2; // this should fail
myclass<unsigned char> m3; // and so should this
int main()
{
return 0;
}

37
static_assert_test_fail_8.cpp Normal file
View File

@ -0,0 +1,37 @@
// (C) Copyright John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <iterator>
#include <list>
#include <deque>
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
template <class RandonAccessIterator >
RandonAccessIterator foo(RandonAccessIterator from, RandonAccessIterator to)
{
// this template can only be used with
// random access iterators...
typedef typename std::iterator_traits< RandonAccessIterator >::iterator_category cat;
BOOST_STATIC_ASSERT((boost::is_convertible<cat, const std::random_access_iterator_tag&>::value));
//
// detail goes here...
return from;
}
int main()
{
std::deque<int> d;
std::list<int> l;
foo(d.begin(), d.end()); // OK
foo(l.begin(), l.end()); // error
return 0;
}

32
static_assert_test_fail_9.cpp Normal file
View File

@ -0,0 +1,32 @@
// (C) Copyright John Maddock 2000.
// Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// See http://www.boost.org for most recent version including documentation.
#include <climits>
#include <limits>
#include <boost/static_assert.hpp>
template <class UnsignedInt>
class myclass
{
private:
BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
&& std::numeric_limits<UnsignedInt>::is_integer
&& !std::numeric_limits<UnsignedInt>::is_signed);
public:
/* details here */
};
myclass<unsigned> m1; // this should be OK
//myclass<int> m2; // this should fail
myclass<unsigned char> m3; // and so should this
int main()
{
return 0;
}