New unit test system: Unit++.
Added test for header::getAllByName/Type
This commit is contained in:
Laurent Richard
parent
3fb6238933
commit
27fb7a5b96
359
tests/lib/unit++/COPYING
Normal file
359
tests/lib/unit++/COPYING
Normal file
@ -0,0 +1,359 @@
|
||||
This program is free software; you can redistribute it and/or modify it under
|
||||
the terms of the GNU General Public License as published by the Free Software
|
||||
Foundation; either version 2 of the License, or (at your option) any later
|
||||
version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
||||
FOR A PARTICULAR PURPOSE.
|
||||
|
||||
See the GNU General Public License for more details. You should have received
|
||||
a copy of the GNU General Public License along with this program; if not,
|
||||
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA.
|
||||
|
||||
The author can be contacted at azhrarn@users.sourceforge.net.
|
||||
|
||||
|
||||
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
|
||||
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
License is intended to guarantee your freedom to share and change free
|
||||
software--to make sure the software is free for all its users. This
|
||||
General Public License applies to most of the Free Software
|
||||
Foundation's software and to any other program whose authors commit to
|
||||
using it. (Some other Free Software Foundation software is covered by
|
||||
the GNU Library General Public License instead.) You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if you
|
||||
distribute copies of the software, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must give the recipients all the rights that
|
||||
you have. You must make sure that they, too, receive or can get the
|
||||
source code. And you must show them these terms so they know their
|
||||
rights.
|
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and
|
||||
(2) offer you this license which gives you legal permission to copy,
|
||||
distribute and/or modify the software.
|
||||
|
||||
Also, for each author's protection and ours, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
software. If the software is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original, so
|
||||
that any problems introduced by others will not reflect on the original
|
||||
authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that redistributors of a free
|
||||
program will individually obtain patent licenses, in effect making the
|
||||
program proprietary. To prevent this, we have made it clear that any
|
||||
patent must be licensed for everyone's free use or not licensed at all.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License applies to any program or other work which contains
|
||||
a notice placed by the copyright holder saying it may be distributed
|
||||
under the terms of this General Public License. The "Program", below,
|
||||
refers to any such program or work, and a "work based on the Program"
|
||||
means either the Program or any derivative work under copyright law:
|
||||
that is to say, a work containing the Program or a portion of it,
|
||||
either verbatim or with modifications and/or translated into another
|
||||
language. (Hereinafter, translation is included without limitation in
|
||||
the term "modification".) Each licensee is addressed as "you".
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running the Program is not restricted, and the output from the Program
|
||||
is covered only if its contents constitute a work based on the
|
||||
Program (independent of having been made by running the Program).
|
||||
Whether that is true depends on what the Program does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's
|
||||
source code as you receive it, in any medium, provided that you
|
||||
conspicuously and appropriately publish on each copy an appropriate
|
||||
copyright notice and disclaimer of warranty; keep intact all the
|
||||
notices that refer to this License and to the absence of any warranty;
|
||||
and give any other recipients of the Program a copy of this License
|
||||
along with the Program.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and
|
||||
you may at your option offer warranty protection in exchange for a fee.
|
||||
|
||||
2. You may modify your copy or copies of the Program or any portion
|
||||
of it, thus forming a work based on the Program, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) You must cause the modified files to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
b) You must cause any work that you distribute or publish, that in
|
||||
whole or in part contains or is derived from the Program or any
|
||||
part thereof, to be licensed as a whole at no charge to all third
|
||||
parties under the terms of this License.
|
||||
|
||||
c) If the modified program normally reads commands interactively
|
||||
when run, you must cause it, when started running for such
|
||||
interactive use in the most ordinary way, to print or display an
|
||||
announcement including an appropriate copyright notice and a
|
||||
notice that there is no warranty (or else, saying that you provide
|
||||
a warranty) and that users may redistribute the program under
|
||||
these conditions, and telling the user how to view a copy of this
|
||||
License. (Exception: if the Program itself is interactive but
|
||||
does not normally print such an announcement, your work based on
|
||||
the Program is not required to print an announcement.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Program,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Program, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Program.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Program
|
||||
with the Program (or with a work based on the Program) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may copy and distribute the Program (or a work based on it,
|
||||
under Section 2) in object code or executable form under the terms of
|
||||
Sections 1 and 2 above provided that you also do one of the following:
|
||||
|
||||
a) Accompany it with the complete corresponding machine-readable
|
||||
source code, which must be distributed under the terms of Sections
|
||||
1 and 2 above on a medium customarily used for software interchange; or,
|
||||
|
||||
b) Accompany it with a written offer, valid for at least three
|
||||
years, to give any third party, for a charge no more than your
|
||||
cost of physically performing source distribution, a complete
|
||||
machine-readable copy of the corresponding source code, to be
|
||||
distributed under the terms of Sections 1 and 2 above on a medium
|
||||
customarily used for software interchange; or,
|
||||
|
||||
c) Accompany it with the information you received as to the offer
|
||||
to distribute corresponding source code. (This alternative is
|
||||
allowed only for noncommercial distribution and only if you
|
||||
received the program in object code or executable form with such
|
||||
an offer, in accord with Subsection b above.)
|
||||
|
||||
The source code for a work means the preferred form of the work for
|
||||
making modifications to it. For an executable work, complete source
|
||||
code means all the source code for all modules it contains, plus any
|
||||
associated interface definition files, plus the scripts used to
|
||||
control compilation and installation of the executable. However, as a
|
||||
special exception, the source code distributed need not include
|
||||
anything that is normally distributed (in either source or binary
|
||||
form) with the major components (compiler, kernel, and so on) of the
|
||||
operating system on which the executable runs, unless that component
|
||||
itself accompanies the executable.
|
||||
|
||||
If distribution of executable or object code is made by offering
|
||||
access to copy from a designated place, then offering equivalent
|
||||
access to copy the source code from the same place counts as
|
||||
distribution of the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program
|
||||
except as expressly provided under this License. Any attempt
|
||||
otherwise to copy, modify, sublicense or distribute the Program is
|
||||
void, and will automatically terminate your rights under this License.
|
||||
However, parties who have received copies, or rights, from you under
|
||||
this License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
|
||||
5. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Program or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Program (or any work based on the
|
||||
Program), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Program or works based on it.
|
||||
|
||||
6. Each time you redistribute the Program (or any work based on the
|
||||
Program), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute or modify the Program subject to
|
||||
these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Program at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Program by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Program.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system, which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
8. If the distribution and/or use of the Program is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Program under this License
|
||||
may add an explicit geographical distribution limitation excluding
|
||||
those countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions
|
||||
of the General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies a version number of this License which applies to it and "any
|
||||
later version", you have the option of following the terms and conditions
|
||||
either of that version or of any later version published by the Free
|
||||
Software Foundation. If the Program does not specify a version number of
|
||||
this License, you may choose any version ever published by the Free Software
|
||||
Foundation.
|
||||
|
||||
10. If you wish to incorporate parts of the Program into other free
|
||||
programs whose distribution conditions are different, write to the author
|
||||
to ask for permission. For software which is copyrighted by the Free
|
||||
Software Foundation, write to the Free Software Foundation; we sometimes
|
||||
make exceptions for this. Our decision will be guided by the two goals
|
||||
of preserving the free status of all derivatives of our free software and
|
||||
of promoting the sharing and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
||||
REPAIR OR CORRECTION.
|
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program is interactive, make it output a short notice like this
|
||||
when it starts in an interactive mode:
|
||||
|
||||
Gnomovision version 69, Copyright (C) year name of author
|
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, the commands you use may
|
||||
be called something other than `show w' and `show c'; they could even be
|
||||
mouse-clicks or menu items--whatever suits your program.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1989
|
||||
Ty Coon, President of Vice
|
||||
|
||||
This General Public License does not permit incorporating your program into
|
||||
proprietary programs. If your program is a subroutine library, you may
|
||||
consider it more useful to permit linking proprietary applications with the
|
||||
library. If this is what you want to do, use the GNU Library General
|
||||
Public License instead of this License.
|
||||
16
tests/lib/unit++/Changelog
Normal file
16
tests/lib/unit++/Changelog
Normal file
@ -0,0 +1,16 @@
|
||||
1.2:
|
||||
Added a couple of man pages.
|
||||
|
||||
Incorporated some changes from Craig McGeachie to allow compilation on
|
||||
MicroSoft Visual Studio.
|
||||
|
||||
Added a Qt GUI
|
||||
|
||||
Added Kenn Knowles' m4 automake configuration file for determining in an
|
||||
automake file if unit++ is available
|
||||
|
||||
Added some typename hints for compilers less large than g++ (thanks to Doug
|
||||
Philips). Should get it to compile on AIX 4.3.3.
|
||||
|
||||
1.1.1:
|
||||
Before this list started...
|
||||
59
tests/lib/unit++/INSTALL
Normal file
59
tests/lib/unit++/INSTALL
Normal file
@ -0,0 +1,59 @@
|
||||
The unit++ framework is meant to be very simple.
|
||||
|
||||
To install it:
|
||||
./configure
|
||||
make install
|
||||
|
||||
This should take care of everything, and install in
|
||||
/usr/local/{lib,include,man}.
|
||||
|
||||
The all target (make all) will make the test for the test framework, unit++.
|
||||
Try to run it to see that everything is fine. If you want to see a failing
|
||||
test case, try `unit++ -f'.
|
||||
|
||||
Graphics
|
||||
--------
|
||||
|
||||
My experience from junit are that a really great day ends with my test suite
|
||||
producing that green bar... To gain that joy in C++ I have made a GUI for
|
||||
unit++ based on Qt. However, it does take longer to run the unGUI version, and
|
||||
I have therefore taken great care that this will still work without it.
|
||||
|
||||
The install instructions for the GUI version is:
|
||||
./configure --with-qt
|
||||
make install
|
||||
|
||||
This will enable the gui, that is add the GUI classes to the unit++ library.
|
||||
It still requires that the individual test programs enables the GUI. This is
|
||||
done by adding the following lines to one of the test modules:
|
||||
|
||||
#include <unit++/unit++.h>
|
||||
unitpp::gui_hook ghook;
|
||||
|
||||
This will enable the -g (or --gui) option in the resulting executable.
|
||||
|
||||
NOTE:
|
||||
=====
|
||||
The tests don't work properly on old C++ compilers, without the <sstream>
|
||||
header (stringstream classes). That includes the g++ 2.95.3 version found on
|
||||
SunOS and OpenBSD. However, newer versions of libstd++3 works fine.
|
||||
|
||||
This means that some things will not be tested in this case, and some
|
||||
spurious output will result from running the unit++ program. The final count
|
||||
of tests is correct, even though the output strongly suggests otherwise.
|
||||
====
|
||||
|
||||
Doc.
|
||||
----
|
||||
If you have doc++ available the API interface can be documented by `make
|
||||
doc'. The DOCDIR variable in the Makefile controls where the files end up.
|
||||
|
||||
If you want the documentation without having doc++, I try to keep it update
|
||||
on the SourceForge page: http://unitpp.sourceforge.net/docs/index.html.
|
||||
|
||||
It can be found as a file for download there as well.
|
||||
|
||||
Man pages
|
||||
---------
|
||||
I have added a man page for unit++(3). This documents the API to a level that
|
||||
I deem sufficient for writing test cases.
|
||||
80
tests/lib/unit++/Makefile.in
Normal file
80
tests/lib/unit++/Makefile.in
Normal file
@ -0,0 +1,80 @@
|
||||
# installation targets
|
||||
prefix=@prefix@
|
||||
includedir=@includedir@
|
||||
exec_prefix=@exec_prefix@
|
||||
libdir=@libdir@
|
||||
mandir=@mandir@
|
||||
docdir=./html/unit++
|
||||
#various compilers.
|
||||
CXX=@CXX@
|
||||
CXXFLAGS=@CXXFLAGS@
|
||||
# for those that have doc++, otherwise get it
|
||||
DOC=doc++
|
||||
#Qt related stuff
|
||||
QT_LIBDIR = @QT_LDFLAGS@
|
||||
QT_INCDIR = @QT_INCLUDES@
|
||||
MOC = @MOC@
|
||||
GUI_OBJS = @gui_vars@
|
||||
GUI_DOCSRC = @gui_docsrc@
|
||||
|
||||
# Below here should not need modification
|
||||
TARGETLIB=libunit++.a
|
||||
TARGETHEADERS=unit++.h optmap.h gui.h guitester.h main.h tester.h
|
||||
# substituted into GUI_OBJS by autoconf, if GUI is enabled
|
||||
gui_objs = gui.o guitester.o moc_gui.o moc_guitester.o
|
||||
gui_docsrc = gui.h guitester.h
|
||||
OBJS=unit++.o tester.o main.o optmap.o $(GUI_OBJS)
|
||||
#the files with doc information
|
||||
DOCSRC=$(TARGETHEADERS) main.h tester.h $(GUI_DOCSRC)
|
||||
DOCOPTS=-d $(docdir)
|
||||
TSTOBJS=Test_unit++.o Test_optmap.o Test_gui.o
|
||||
TSTLIBS=-L. -lunit++
|
||||
|
||||
.SUFFIXES: .cc
|
||||
|
||||
.cc.o:
|
||||
$(CXX) -D__UNITPP -c $(CXXFLAGS) $(CPPFLAGS) @QT_INCLUDES@ @DEFS@ -o $@ $<
|
||||
|
||||
all: $(TARGETLIB) unit++
|
||||
|
||||
$(TARGETLIB): $(OBJS)
|
||||
ar r $@ $(OBJS)
|
||||
|
||||
install: $(TARGETLIB) $(TARGETHEADERS)
|
||||
[ -d $(libdir) ] || mkdir -p $(libdir)
|
||||
[ -d $(includedir)/unit++ ] || mkdir -p $(includedir)/unit++
|
||||
[ -d $(mandir)/man1 ] || mkdir -p $(mandir)/man1
|
||||
[ -d $(mandir)/man3 ] || mkdir -p $(mandir)/man3
|
||||
cp $(TARGETLIB) $(libdir)
|
||||
cp $(TARGETHEADERS) $(includedir)/unit++
|
||||
cp unit++-compat.h $(includedir)/unit++.h
|
||||
cp optmap-compat.h $(includedir)/optmap.h
|
||||
cp unit++.1 $(mandir)/man1
|
||||
cp unit++.3 $(mandir)/man3
|
||||
|
||||
doc: $(DOCSRC)
|
||||
[ -d $(docdir) ] || mkdir -p $(docdir)
|
||||
doc++ $(DOCOPTS) $(DOCSRC)
|
||||
|
||||
unit++: $(TSTOBJS) $(TARGETLIB)
|
||||
$(CXX) -o $@ $(TSTOBJS) $(TSTLIBS) @QT_LDFLAGS@ @qt_lib@
|
||||
|
||||
moc_gui.cc: gui.h
|
||||
$(MOC) $< -o $@
|
||||
moc_guitester.cc: guitester.h
|
||||
$(MOC) $< -o $@
|
||||
clean:
|
||||
rm -f $(OBJS) $(TSTOBJS)
|
||||
|
||||
clobber: clean
|
||||
rm -f $(TARGETLIB) unit++
|
||||
|
||||
Test_optmap.o: Test_optmap.cc unit++.h optmap.h
|
||||
Test_unit++.o: Test_unit++.cc unit++.h optmap.h tester.h main.h
|
||||
Test_gui.o: Test_gui.cc
|
||||
gui.o: gui.cc gui.h unit++.h optmap.h
|
||||
guitester.o: guitester.cc
|
||||
main.o: main.cc main.h tester.h unit++.h optmap.h
|
||||
optmap.o: optmap.cc optmap.h
|
||||
tester.o: tester.cc tester.h unit++.h optmap.h
|
||||
unit++.o: unit++.cc unit++.h optmap.h
|
||||
27
tests/lib/unit++/Test_gui.cc
Normal file
27
tests/lib/unit++/Test_gui.cc
Normal file
@ -0,0 +1,27 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#ifdef GUI
|
||||
#include "gui.h"
|
||||
#include "unit++.h"
|
||||
using namespace std;
|
||||
using namespace unitpp;
|
||||
|
||||
gui_hook ghook; // ensure linkage of the gui stuff
|
||||
|
||||
namespace {
|
||||
// The test suite for the gui components
|
||||
class Test : public suite
|
||||
{
|
||||
void dummy()
|
||||
{
|
||||
}
|
||||
public:
|
||||
Test() : suite("GUI test suite")
|
||||
{
|
||||
suite::main().add("gui", this);
|
||||
add("dummy", testcase(this, "Test nothing", &Test::dummy));
|
||||
}
|
||||
} * theTest = new Test();
|
||||
|
||||
}
|
||||
#endif
|
||||
101
tests/lib/unit++/Test_optmap.cc
Normal file
101
tests/lib/unit++/Test_optmap.cc
Normal file
@ -0,0 +1,101 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#include "unit++.h"
|
||||
#include "optmap.h"
|
||||
#include <iostream>
|
||||
#ifdef HAVE_SSTREAM
|
||||
#include <sstream>
|
||||
#endif
|
||||
using namespace std;
|
||||
using namespace unitpp;
|
||||
using namespace options_utils;
|
||||
namespace {
|
||||
const char* x[] = { "testing", "-i", "120", "-n100", "-t" };
|
||||
#ifdef HAVE_SSTREAM
|
||||
class hijack {
|
||||
ostream& os;
|
||||
streambuf* sbp;
|
||||
stringbuf sb;
|
||||
public:
|
||||
hijack(ostream& os)
|
||||
: os(os), sbp(os.rdbuf())
|
||||
{
|
||||
os.rdbuf(&sb);
|
||||
}
|
||||
~hijack() { os.rdbuf(sbp); }
|
||||
string str() { return sb.str(); }
|
||||
};
|
||||
#endif
|
||||
// The test suite for the optmap library
|
||||
class Test : public suite
|
||||
{
|
||||
const char** argv;
|
||||
int argc;
|
||||
void create()
|
||||
{
|
||||
optmap om;
|
||||
}
|
||||
void usage()
|
||||
{
|
||||
bool t_flg;
|
||||
int i = 7;
|
||||
int n = 0;
|
||||
optmap om;
|
||||
om.add("t", new opt_flag(t_flg));
|
||||
om.add("i", new opt_int(i));
|
||||
om.add("n", new opt_int(n));
|
||||
om.alias("number", "n");
|
||||
#ifdef HAVE_SSTREAM
|
||||
string exp(
|
||||
"usage: testing [ -t ] [ -i <int> ] [( -n | --number) <int> ]\n");
|
||||
{
|
||||
hijack s(cerr);
|
||||
om.parse(argc, argv);
|
||||
om.usage(false);
|
||||
assert_eq("usage", exp, s.str());
|
||||
}
|
||||
#endif
|
||||
}
|
||||
void args()
|
||||
{
|
||||
bool t_flg = false;
|
||||
int i = 7;
|
||||
int n = 0;
|
||||
optmap om;
|
||||
om.add("t", new opt_flag(t_flg));
|
||||
om.add("i", new opt_int(i));
|
||||
om.add("n", new opt_int(n));
|
||||
assert_true("parse ok", om.parse(argc, argv));
|
||||
assert_eq("get -i", 120, i);
|
||||
assert_eq("get -n", 100, n);
|
||||
assert_eq("got -t", true, t_flg);
|
||||
}
|
||||
void tail()
|
||||
{
|
||||
const char* argv[] = { "xyzzy", "-abc", "-def", "hij" };
|
||||
size_t argc = sizeof(argv)/sizeof(argv[0]);
|
||||
string s;
|
||||
bool f_d, f_e, f_f;
|
||||
optmap om;
|
||||
om.add("a", new opt_string(s));
|
||||
om.add("d", new opt_flag(f_d));
|
||||
om.add("e", new opt_flag(f_e));
|
||||
om.add("f", new opt_flag(f_f));
|
||||
assert_true("parse", om.parse(static_cast<int>(argc), argv));
|
||||
assert_eq("n", argc - 1, size_t(om.n()));
|
||||
assert_eq("a", "bc", s);
|
||||
}
|
||||
public:
|
||||
Test() : suite("optmap test suite")
|
||||
{
|
||||
argv = x;
|
||||
argc = sizeof(x)/sizeof(char*);
|
||||
suite::main().add("optmap", this);
|
||||
add("create", testcase(this, "Create an optmap", &Test::create));
|
||||
add("usage", testcase(this, "Optmap usage", &Test::usage));
|
||||
add("args", testcase(this, "Optmap args", &Test::args));
|
||||
add("tail", testcase(this, "Optmap tail", &Test::tail));
|
||||
}
|
||||
} * theTest = new Test();
|
||||
|
||||
}
|
||||
194
tests/lib/unit++/Test_unit++.cc
Normal file
194
tests/lib/unit++/Test_unit++.cc
Normal file
@ -0,0 +1,194 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#include "unit++.h"
|
||||
#include "tester.h"
|
||||
#include "main.h"
|
||||
#ifdef HAVE_SSTREAM
|
||||
#include <sstream>
|
||||
#else
|
||||
#include <iostream>
|
||||
#endif
|
||||
using namespace std;
|
||||
using namespace unitpp;
|
||||
namespace {
|
||||
|
||||
// a test case that can fail with any exception
|
||||
class test_test : public test
|
||||
{
|
||||
public:
|
||||
enum result { succes, fail, error, exotic };
|
||||
test_test(string name, result res = succes) : test(name), res(res) {}
|
||||
virtual void operator()()
|
||||
{
|
||||
switch (res) {
|
||||
case succes: break;
|
||||
case fail: ::fail("test_test");
|
||||
case error: throw out_of_range("ranged");
|
||||
case exotic: throw 4711;
|
||||
}
|
||||
}
|
||||
private:
|
||||
result res;
|
||||
};
|
||||
|
||||
// The test suite for the unit++ library
|
||||
class Test : public suite
|
||||
{
|
||||
void create()
|
||||
{
|
||||
test_test a_loc_test("local");
|
||||
}
|
||||
void assert_ok()
|
||||
{
|
||||
string s("ok");
|
||||
assert_true("assert_true(true)", true);
|
||||
assert_eq("assert_eq(int)", 7, 7);
|
||||
assert_eq("assert_eq(char*, string)", "ok", s);
|
||||
}
|
||||
void assert_fail()
|
||||
{
|
||||
string s("fejl");
|
||||
bool ok = true;
|
||||
try {
|
||||
assert_true("assert_true(false)", false);
|
||||
ok = false;
|
||||
} catch (assertion_error e) {
|
||||
#ifdef HAVE_SSTREAM
|
||||
ostringstream oss;
|
||||
oss << e;
|
||||
assert_eq("assert_true(false) output",
|
||||
"assert_true(false) [assertion failed]", oss.str());
|
||||
#endif
|
||||
}
|
||||
if (!ok)
|
||||
fail("no exception from assert_true(false)");
|
||||
try {
|
||||
assert_eq("assert_eq(int)", 5, 7);
|
||||
ok = false;
|
||||
} catch (assert_value_error<int,int> e) {
|
||||
#ifdef HAVE_SSTREAM
|
||||
ostringstream oss;
|
||||
oss << e;
|
||||
assert_eq("assert_eq(int) output",
|
||||
"assert_eq(int) [expected: `5' got: `7']", oss.str());
|
||||
#endif
|
||||
}
|
||||
if (!ok)
|
||||
fail("no exception from assert_eq(int)");
|
||||
try {
|
||||
assert_eq("assert_eq(char*, string)", "ok", s);
|
||||
ok = false;
|
||||
} catch (assert_value_error<const char*, string> e) {
|
||||
} catch (assert_value_error<char*, string> e) { // MSVC++ bug
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
fail("no exception from assert_eq(const char*, string)");
|
||||
}
|
||||
void tester_visit()
|
||||
{
|
||||
out_of_range oor("negative");
|
||||
assertion_error ae("test");
|
||||
#ifdef HAVE_SSTREAM
|
||||
ostringstream os;
|
||||
tester tst(os);
|
||||
#else
|
||||
tester tst(cerr);
|
||||
#endif
|
||||
root.visit(&tst);
|
||||
assert_eq("tests ok", 3, tst.res_tests().n_ok());
|
||||
assert_eq("tests error", 2, tst.res_tests().n_err());
|
||||
assert_eq("tests fail", 1, tst.res_tests().n_fail());
|
||||
assert_eq("suites ok", 1, tst.res_suites().n_ok());
|
||||
assert_eq("suites error", 2, tst.res_suites().n_err());
|
||||
assert_eq("suites fail", 1, tst.res_suites().n_fail());
|
||||
}
|
||||
void ex_test()
|
||||
{
|
||||
throw out_of_range("expected");
|
||||
}
|
||||
void get_by_id()
|
||||
{
|
||||
test* p = root.get_child("s2");
|
||||
assert_true("found s2", p != 0);
|
||||
suite* sp = dynamic_cast<suite*>(p);
|
||||
assert_true("s2 was suite", sp != 0);
|
||||
assert_eq("right s2", "S2", sp->name());
|
||||
p = sp->get_child("t20");
|
||||
assert_true("found t20", p != 0);
|
||||
assert_eq("not suite", static_cast<suite*>(0),dynamic_cast<suite*>(p));
|
||||
}
|
||||
void vec()
|
||||
{
|
||||
string s = "three.blind.mice";
|
||||
vector<string> v(vectorize(s,'.'));
|
||||
assert_eq("v[0]", string("three"), v[0]);
|
||||
assert_eq("v[1]", string("blind"), v[1]);
|
||||
assert_eq("v[2]", string("mice"), v[2]);
|
||||
assert_eq("size", size_t(3), v.size());
|
||||
v = vectorize(s,'-');
|
||||
assert_eq("no match", s, v[0]);
|
||||
assert_eq("no match size", size_t(1), v.size());
|
||||
}
|
||||
void empty_vec()
|
||||
{
|
||||
string s("");
|
||||
vector<string> v(vectorize(s,'.'));
|
||||
assert_eq("size", size_t(0), v.size());
|
||||
s = "one..three";
|
||||
v = vectorize(s,'.');
|
||||
assert_eq("v[0]", string("one"), v[0]);
|
||||
assert_eq("v[1]", string(""), v[1]);
|
||||
assert_eq("v[2]", string("three"), v[2]);
|
||||
assert_eq("size", size_t(3), v.size());
|
||||
}
|
||||
void find()
|
||||
{
|
||||
test* tp = root.find("s2.s21.t210");
|
||||
assert_eq("t210", t210, tp);
|
||||
tp = root.find("s1.s21");
|
||||
assert_eq("bad mid", static_cast<test*>(0), tp);
|
||||
}
|
||||
suite root;
|
||||
test* t210;
|
||||
bool do_fail;
|
||||
void fail_on_flag()
|
||||
{
|
||||
assert_true("Fail option not set", !do_fail);
|
||||
}
|
||||
public:
|
||||
Test() : suite("Unit++ test suite"), root("The root")
|
||||
{
|
||||
do_fail = false;
|
||||
options().add("f", new options_utils::opt_flag(do_fail));
|
||||
options().alias("fail", "f");
|
||||
suite* s1;
|
||||
suite* s2;
|
||||
suite* s21;
|
||||
root.add("s1", s1 = new suite("S1"));
|
||||
root.add("s2", s2 = new suite("S2"));
|
||||
s2->add("s21", s21 = new suite("S21"));
|
||||
s1->add("t10", new test_test("T10"));
|
||||
s1->add("t11", new test_test("T11"));
|
||||
s2->add("t20", new test_test("T20", test_test::error));
|
||||
s2->add("t22", new test_test("T22", test_test::exotic));
|
||||
s21->add("t210", t210 = new test_test("T210"));
|
||||
s21->add("t211", new test_test("T211", test_test::fail));
|
||||
//
|
||||
// Adding testcases
|
||||
suite::main().add("unitpp", this);
|
||||
add("create", testcase(this, "Create a test", &Test::create));
|
||||
add("assert_ok", testcase(this, "Assert ok", &Test::assert_ok));
|
||||
add("assert_fail", testcase(this, "Assert fail", &Test::assert_fail));
|
||||
add("tester_visit", testcase(this, "Visit", &Test::tester_visit));
|
||||
add("exception", testcase(new exception_test<out_of_range>(
|
||||
testcase(this, "gen ex", &Test::ex_test))));
|
||||
add("id_get", testcase(this, "Get by id", &Test::get_by_id));
|
||||
add("vec", testcase(this, "Vectorize", &Test::vec));
|
||||
add("empty_vec", testcase(this, "Vectorize empty", &Test::empty_vec));
|
||||
add("find", testcase(this, "find", &Test::find));
|
||||
add("fail", testcase(this, "fail on option", &Test::fail_on_flag));
|
||||
}
|
||||
} * theTest = new Test();
|
||||
|
||||
}
|
||||
314
tests/lib/unit++/aclocal.m4
vendored
Normal file
314
tests/lib/unit++/aclocal.m4
vendored
Normal file
@ -0,0 +1,314 @@
|
||||
dnl aclocal.m4 generated automatically by aclocal 1.4-p4
|
||||
|
||||
dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
|
||||
dnl This file is free software; the Free Software Foundation
|
||||
dnl gives unlimited permission to copy and/or distribute it,
|
||||
dnl with or without modifications, as long as this notice is preserved.
|
||||
|
||||
dnl This program is distributed in the hope that it will be useful,
|
||||
dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
||||
dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||
dnl PARTICULAR PURPOSE.
|
||||
|
||||
|
||||
dnl This file is part of QXi, the Qt XInput Extension.
|
||||
dnl
|
||||
dnl Copyright (C) 2000 Daniel Schmitt <pnambic@unu.nu>
|
||||
dnl
|
||||
dnl This file may be distributed under the terms of the Q Public License as
|
||||
dnl appearing in the file COPYING.QPL included in the packaging of this file.
|
||||
dnl
|
||||
dnl The portions of this file that deal with the detection of Qt are
|
||||
dnl stripped-down versions of macros used in KDE (http://www.kde.org/).
|
||||
dnl
|
||||
dnl The originals are copyrighted by
|
||||
dnl Copyright (C) 1997 Janos Farkas (chexum@shadow.banki.hu)
|
||||
dnl (C) 1997,98,99 Stephan Kulow (coolo@kde.org)
|
||||
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl Find a file (or one of more files in a list of dirs)
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl
|
||||
AC_DEFUN(AC_FIND_FILE,
|
||||
[
|
||||
$3=NO
|
||||
for i in $2;
|
||||
do
|
||||
for j in $1;
|
||||
do
|
||||
if test -r "$i/$j"; then
|
||||
$3=$i
|
||||
break 2
|
||||
fi
|
||||
done
|
||||
done
|
||||
])
|
||||
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl Find the meta object compiler in the PATH, in $QTDIR/bin, and some
|
||||
dnl more usual places
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl
|
||||
AC_DEFUN(AC_PATH_QT_MOC,
|
||||
[
|
||||
AC_PATH_PROG(MOC, moc, "", $ac_qt_bindir:$QTDIR/bin:$QTDIR/src/moc:/usr/bin /usr/X11R6/bin:/usr/lib/qt/bin:/usr/lib/qt2/bin:/usr/local/qt/bin:$PATH)
|
||||
|
||||
if test -z "$MOC"; then
|
||||
if test -n "$ac_cv_path_moc"; then
|
||||
output=`eval "$ac_cv_path_moc --help 2>&1 | sed -e '1q' | grep Qt"`
|
||||
fi
|
||||
echo "configure:__oline__: tried to call $ac_cv_path_moc --help 2>&1 | sed -e '1q' | grep Qt" >&AC_FD_CC
|
||||
echo "configure:__oline__: moc output: $output" >&AC_FD_CC
|
||||
|
||||
if test -z "$output"; then
|
||||
AC_MSG_ERROR([No Qt meta object compiler (moc) found!
|
||||
Please check whether you installed Qt correctly.
|
||||
You need to have a running moc binary.
|
||||
configure tried to run $ac_cv_path_moc and the test didn't
|
||||
succeed. If configure shouldn't have tried this one, set
|
||||
the environment variable MOC to the right one before running
|
||||
configure.
|
||||
])
|
||||
fi
|
||||
fi
|
||||
|
||||
AC_SUBST(MOC)
|
||||
])
|
||||
|
||||
AC_DEFUN(AC_PRINT_QT_PROGRAM,
|
||||
[
|
||||
cat > conftest.$ac_ext <<EOF
|
||||
#include "confdefs.h"
|
||||
#include <qglobal.h>
|
||||
#include <qapplication.h>
|
||||
#include <qstyle.h>
|
||||
|
||||
int main() {
|
||||
QStringList *t = new QStringList();
|
||||
|
||||
return 0;
|
||||
}
|
||||
EOF
|
||||
])
|
||||
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl Try to find the Qt headers and libraries.
|
||||
dnl $(QT_LDFLAGS) will be -Lqtliblocation (if needed)
|
||||
dnl and $(QT_INCLUDES) will be -Iqthdrlocation (if needed)
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl
|
||||
AC_DEFUN(AC_PATH_QT,
|
||||
[
|
||||
LIBQT="-lqt"
|
||||
AC_MSG_CHECKING([for Qt])
|
||||
|
||||
ac_qt_includes=NO ac_qt_libraries=NO ac_qt_bindir=NO
|
||||
qt_libraries=""
|
||||
qt_includes=""
|
||||
AC_ARG_WITH(qt-dir,
|
||||
[ --with-qt-dir=DIR where the root of Qt is installed ],
|
||||
[ ac_qt_includes="$withval"/include
|
||||
ac_qt_libraries="$withval"/lib
|
||||
ac_qt_bindir="$withval"/bin
|
||||
])
|
||||
|
||||
AC_ARG_WITH(qt-includes,
|
||||
[ --with-qt-includes=DIR where the Qt includes are. ],
|
||||
[
|
||||
ac_qt_includes="$withval"
|
||||
])
|
||||
|
||||
ac_qt_libs_given=no
|
||||
|
||||
AC_ARG_WITH(qt-libraries,
|
||||
[ --with-qt-libraries=DIR where the Qt library is installed.],
|
||||
[ ac_qt_libraries="$withval"
|
||||
ac_qt_libs_given=yes
|
||||
])
|
||||
|
||||
AC_CACHE_VAL(ac_cv_have_qt,
|
||||
[#try to guess Qt locations
|
||||
|
||||
qt_incdirs="$QTINC /usr/lib/qt/include /usr/local/qt/include /usr/include/qt3 /usr/include/qt /usr/include /usr/lib/qt2/include /usr/X11R6/include/X11/qt $x_includes"
|
||||
test -n "$QTDIR" && qt_incdirs="$QTDIR/include $QTDIR $qt_incdirs"
|
||||
qt_incdirs="$ac_qt_includes $qt_incdirs"
|
||||
AC_FIND_FILE(qstyle.h, $qt_incdirs, qt_incdir)
|
||||
ac_qt_includes="$qt_incdir"
|
||||
|
||||
qt_libdirs="$QTLIB /usr/lib/qt/lib /usr/X11R6/lib /usr/lib /usr/local/qt/lib /usr/lib/qt /usr/lib/qt2/lib $x_libraries"
|
||||
test -n "$QTDIR" && qt_libdirs="$QTDIR/lib $QTDIR $qt_libdirs"
|
||||
if test ! "$ac_qt_libraries" = "NO"; then
|
||||
qt_libdirs="$ac_qt_libraries $qt_libdirs"
|
||||
fi
|
||||
|
||||
test=NONE
|
||||
qt_libdir=NONE
|
||||
for dir in $qt_libdirs; do
|
||||
try="ls -1 $dir/libqt*"
|
||||
if test=`eval $try 2> /dev/null`; then qt_libdir=$dir; break; else echo "tried $dir" >&AC_FD_CC ; fi
|
||||
done
|
||||
|
||||
ac_qt_libraries="$qt_libdir"
|
||||
|
||||
AC_LANG_SAVE
|
||||
AC_LANG_CPLUSPLUS
|
||||
|
||||
ac_cxxflags_safe="$CXXFLAGS"
|
||||
ac_ldflags_safe="$LDFLAGS"
|
||||
ac_libs_safe="$LIBS"
|
||||
|
||||
CXXFLAGS="$CXXFLAGS -I$qt_incdir $all_includes"
|
||||
LDFLAGS="-L$x_libraries -L$qt_libdir $all_libraries"
|
||||
LIBS="$LIBS $LIBQT"
|
||||
|
||||
AC_PRINT_QT_PROGRAM
|
||||
|
||||
if AC_TRY_EVAL(ac_link) && test -s conftest; then
|
||||
rm -f conftest*
|
||||
else
|
||||
echo "configure: failed program was:" >&AC_FD_CC
|
||||
cat conftest.$ac_ext >&AC_FD_CC
|
||||
ac_qt_libraries="NO"
|
||||
fi
|
||||
rm -f conftest*
|
||||
CXXFLAGS="$ac_cxxflags_safe"
|
||||
LDFLAGS="$ac_ldflags_safe"
|
||||
LIBS="$ac_libs_safe"
|
||||
|
||||
AC_LANG_RESTORE
|
||||
if test "$ac_qt_includes" = NO || test "$ac_qt_libraries" = NO; then
|
||||
ac_cv_have_qt="have_qt=no"
|
||||
ac_qt_notfound=""
|
||||
if test "$ac_qt_includes" = NO; then
|
||||
if test "$ac_qt_libraries" = NO; then
|
||||
ac_qt_notfound="(headers and libraries)";
|
||||
else
|
||||
ac_qt_notfound="(headers)";
|
||||
fi
|
||||
else
|
||||
ac_qt_notfound="(libraries)";
|
||||
fi
|
||||
|
||||
AC_MSG_ERROR([Qt 2 not found. Please check your installation! ]);
|
||||
else
|
||||
have_qt="yes"
|
||||
fi
|
||||
])
|
||||
|
||||
eval "$ac_cv_have_qt"
|
||||
|
||||
if test "$have_qt" != yes; then
|
||||
AC_MSG_RESULT([$have_qt]);
|
||||
else
|
||||
ac_cv_have_qt="have_qt=yes \
|
||||
ac_qt_includes=$ac_qt_includes ac_qt_libraries=$ac_qt_libraries"
|
||||
AC_MSG_RESULT([libraries $ac_qt_libraries, headers $ac_qt_includes])
|
||||
|
||||
qt_libraries="$ac_qt_libraries"
|
||||
qt_includes="$ac_qt_includes"
|
||||
fi
|
||||
|
||||
AC_SUBST(qt_libraries)
|
||||
AC_SUBST(qt_includes)
|
||||
|
||||
if test "$qt_includes" = "$x_includes" || test -z "$qt_includes"; then
|
||||
QT_INCLUDES="";
|
||||
else
|
||||
QT_INCLUDES="-I$qt_includes"
|
||||
all_includes="$QT_INCLUDES $all_includes"
|
||||
fi
|
||||
|
||||
if test "$qt_libraries" = "$x_libraries" || test -z "$qt_libraries"; then
|
||||
QT_LDFLAGS=""
|
||||
else
|
||||
QT_LDFLAGS="-L$qt_libraries"
|
||||
all_libraries="$QT_LDFLAGS $all_libraries"
|
||||
fi
|
||||
|
||||
AC_SUBST(QT_INCLUDES)
|
||||
AC_SUBST(QT_LDFLAGS)
|
||||
AC_PATH_QT_MOC
|
||||
|
||||
LIB_QT='-lqt'
|
||||
AC_SUBST(LIB_QT)
|
||||
|
||||
])
|
||||
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl Find libz (required by libpng)
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl
|
||||
AC_DEFUN(AC_FIND_ZLIB,
|
||||
[
|
||||
AC_MSG_CHECKING([for libz])
|
||||
AC_CACHE_VAL(ac_cv_lib_z,
|
||||
[
|
||||
AC_LANG_C
|
||||
ac_save_LIBS="$LIBS"
|
||||
LIBS="$all_libraries -lz $LIBSOCKET"
|
||||
ac_save_CFLAGS="$CFLAGS"
|
||||
CFLAGS="$CFLAGS $all_includes"
|
||||
AC_TRY_LINK(dnl
|
||||
[
|
||||
#include<zlib.h>
|
||||
],
|
||||
[return (zlibVersion() == ZLIB_VERSION); ],
|
||||
eval "ac_cv_lib_z='-lz'",
|
||||
eval "ac_cv_lib_z=no")
|
||||
LIBS="$ac_save_LIBS"
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
])dnl
|
||||
if eval "test ! \"`echo $ac_cv_lib_z`\" = no"; then
|
||||
AC_DEFINE_UNQUOTED(HAVE_LIBZ, 1, [Define if you have libz])
|
||||
LIBZ="$ac_cv_lib_z"
|
||||
AC_SUBST(LIBZ)
|
||||
AC_MSG_RESULT($ac_cv_lib_z)
|
||||
else
|
||||
AC_MSG_RESULT(no)
|
||||
LIBZ=""
|
||||
AC_SUBST(LIBZ)
|
||||
fi
|
||||
])
|
||||
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl Find libpng (required by Qt 2)
|
||||
dnl ------------------------------------------------------------------------
|
||||
dnl
|
||||
AC_DEFUN(AC_FIND_PNG,
|
||||
[
|
||||
AC_REQUIRE([AC_FIND_ZLIB])
|
||||
AC_MSG_CHECKING([for libpng])
|
||||
AC_CACHE_VAL(ac_cv_lib_png,
|
||||
[
|
||||
ac_save_LIBS="$LIBS"
|
||||
LIBS="$LIBS $all_libraries -lpng $LIBZ -lm -lX11 $LIBSOCKET"
|
||||
ac_save_CFLAGS="$CFLAGS"
|
||||
CFLAGS="$CFLAGS $all_includes"
|
||||
AC_LANG_C
|
||||
AC_TRY_LINK(dnl
|
||||
[
|
||||
#include<png.h>
|
||||
],
|
||||
[
|
||||
png_structp png_ptr = png_create_read_struct( /* image ptr */
|
||||
PNG_LIBPNG_VER_STRING, 0, 0, 0 );
|
||||
return( png_ptr != 0 );
|
||||
],
|
||||
eval "ac_cv_lib_png='-lpng $LIBZ -lm'",
|
||||
eval "ac_cv_lib_png=no"
|
||||
)
|
||||
LIBS="$ac_save_LIBS"
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
])dnl
|
||||
if eval "test ! \"`echo $ac_cv_lib_png`\" = no"; then
|
||||
AC_DEFINE_UNQUOTED(HAVE_LIBPNG, 1, [Define if you have libpng])
|
||||
LIBPNG="$ac_cv_lib_png"
|
||||
AC_SUBST(LIBPNG)
|
||||
AC_MSG_RESULT($ac_cv_lib_png)
|
||||
else
|
||||
AC_MSG_RESULT(no)
|
||||
LIBPNG=""
|
||||
AC_SUBST(LIBPNG)
|
||||
fi
|
||||
])
|
||||
|
||||
3599
tests/lib/unit++/configure
vendored
Executable file
3599
tests/lib/unit++/configure
vendored
Executable file
File diff suppressed because it is too large
Load Diff
32
tests/lib/unit++/configure.ac
Normal file
32
tests/lib/unit++/configure.ac
Normal file
@ -0,0 +1,32 @@
|
||||
# Process this file with autoconf to produce a configure script.
|
||||
AC_INIT(FULL-PACKAGE-NAME, VERSION, BUG-REPORT-ADDRESS)
|
||||
AC_LANG(C++)
|
||||
AC_CONFIG_SRCDIR([Test_optmap.cc])
|
||||
AC_ARG_WITH(qt, AC_HELP_STRING([--with-qt], [use Qt gui (default no)]),
|
||||
[ac_use_qt=yes], [ac_use_qt=no])
|
||||
|
||||
# Checks for programs.
|
||||
AC_PROG_CXX
|
||||
# AC_PROG_INSTALL
|
||||
|
||||
# Checks for libraries.
|
||||
if test "$ac_use_qt" = yes; then
|
||||
AC_PATH_QT
|
||||
AC_DEFINE([GUI])
|
||||
gui_vars='$(gui_objs)'
|
||||
gui_docsrc='$(gui_docsrc)'
|
||||
qt_lib='-lqt'
|
||||
fi
|
||||
AC_SUBST(gui_vars)
|
||||
AC_SUBST(gui_docsrc)
|
||||
AC_SUBST(qt_lib)
|
||||
|
||||
# Checks for header files.
|
||||
AC_CHECK_HEADERS([sstream])
|
||||
|
||||
# Checks for typedefs, structures, and compiler characteristics.
|
||||
|
||||
# Checks for library functions.
|
||||
|
||||
AC_CONFIG_FILES([Makefile])
|
||||
AC_OUTPUT
|
||||
313
tests/lib/unit++/gui.cc
Normal file
313
tests/lib/unit++/gui.cc
Normal file
@ -0,0 +1,313 @@
|
||||
#include <algorithm>
|
||||
#include "gui.h"
|
||||
#include "unit++.h"
|
||||
#ifdef HAVE_SSTREAM
|
||||
#include <sstream>
|
||||
#endif
|
||||
using namespace unitpp;
|
||||
using namespace std;
|
||||
|
||||
#ifdef GUI
|
||||
static const char* const img_error[] = {
|
||||
"14 14 2 1",
|
||||
". c #ff0000",
|
||||
"# c #ffffff",
|
||||
"...########...",
|
||||
"....######....",
|
||||
".....####.....",
|
||||
"#.....##.....#",
|
||||
"##..........##",
|
||||
"###........###",
|
||||
"####......####",
|
||||
"####......####",
|
||||
"###........###",
|
||||
"##..........##",
|
||||
"#.....##.....#",
|
||||
".....####.....",
|
||||
"....######....",
|
||||
"...########..."};
|
||||
|
||||
static const char* const img_fail[] = {
|
||||
"14 14 2 1",
|
||||
"# c #ff0000",
|
||||
". c #ffffff",
|
||||
"..............",
|
||||
".##........##.",
|
||||
".###......###.",
|
||||
"..###....###..",
|
||||
"...###..###...",
|
||||
"....######....",
|
||||
".....####.....",
|
||||
".....####.....",
|
||||
"....######....",
|
||||
"...###..###...",
|
||||
"..###....###..",
|
||||
".###......###.",
|
||||
".##........##.",
|
||||
".............."};
|
||||
|
||||
static const char* const img_ok[] = {
|
||||
"14 14 3 1",
|
||||
"# c #00ff00",
|
||||
"a c #00ff6a",
|
||||
". c #ffffff",
|
||||
"..........###.",
|
||||
".........###..",
|
||||
"........#a#...",
|
||||
"........aa#...",
|
||||
".......#aa....",
|
||||
".......#a.....",
|
||||
"......#aa.....",
|
||||
"#.....aa#.....",
|
||||
"###..#a#......",
|
||||
".##.##a.......",
|
||||
"..#aaa#.......",
|
||||
"...#aa#.......",
|
||||
"....##........",
|
||||
".....#........"};
|
||||
|
||||
static const char* const img_empty[] = {
|
||||
"14 14 2 1",
|
||||
". c #f0f0f0",
|
||||
"# c #ffffff",
|
||||
"..............",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".############.",
|
||||
".............."};
|
||||
|
||||
|
||||
cnt_item::cnt_item(QWidget* par, const QString& txt, const QColor& col,
|
||||
const char* name)
|
||||
: QHBox(par, name), v(0)
|
||||
{
|
||||
setSpacing(3);
|
||||
setMargin(5);
|
||||
val = new QLabel("0", this);
|
||||
val->setAlignment(QLabel::AlignVCenter | QLabel::AlignRight);
|
||||
QPalette pal(val->palette());
|
||||
QColorGroup cg(pal.active());
|
||||
cg.setColor(QColorGroup::Foreground, col);
|
||||
pal.setActive(cg);
|
||||
val->setPalette(pal);
|
||||
label = new QLabel(txt, this);
|
||||
}
|
||||
void cnt_item::value(int iv)
|
||||
{
|
||||
v = iv;
|
||||
val->setNum(v);
|
||||
}
|
||||
void cnt_item::inc()
|
||||
{
|
||||
value(v+1);
|
||||
}
|
||||
|
||||
cnt_line::cnt_line(const QString& txt, QWidget* par, const char* name)
|
||||
: QHBox(par, name)
|
||||
{
|
||||
label = new QLabel(txt, this);
|
||||
QFont font(label->font());
|
||||
font.setBold(true);
|
||||
label->setFont(font);
|
||||
cnts[0] = new cnt_item(this, "Total");
|
||||
cnts[1] = new cnt_item(this, "OK", green);
|
||||
cnts[2] = new cnt_item(this, "Fail", red);
|
||||
cnts[3] = new cnt_item(this, "Error", red);
|
||||
setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
|
||||
}
|
||||
|
||||
void cnt_line::max(int m) { cnts[id_max]->value(m); }
|
||||
void cnt_line::inc_ok() { cnts[id_ok]->inc(); }
|
||||
void cnt_line::inc_fail() { cnts[id_fail]->inc(); }
|
||||
void cnt_line::inc_error() { cnts[id_error]->inc(); }
|
||||
void cnt_line::reset()
|
||||
{
|
||||
for (int i = id_ok; i < n_id; ++i)
|
||||
cnts[i]->value(0);
|
||||
}
|
||||
|
||||
res_stack::res_stack(const QString& txt, QWidget* par, const char* name)
|
||||
: QVBox(par, name)
|
||||
{
|
||||
cnts = new cnt_line(txt, this, name);
|
||||
bar = new QProgressBar(this);
|
||||
setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
|
||||
}
|
||||
void res_stack::max(int v)
|
||||
{
|
||||
cnts->max(v);
|
||||
bar->setTotalSteps(v);
|
||||
}
|
||||
void res_stack::inc_progress(bool err)
|
||||
{
|
||||
QPalette pal(bar->palette());
|
||||
QColorGroup cg(pal.active());
|
||||
QColor red(255,0,0);
|
||||
QColor green(0,244,0);
|
||||
cg.setColor(QColorGroup::Highlight, err ? red : green);
|
||||
cg.setColor(QColorGroup::HighlightedText, black);
|
||||
pal.setActive(cg);
|
||||
pal.setInactive(cg);
|
||||
pal.setDisabled(cg);
|
||||
bar->setPalette(pal);
|
||||
bar->setProgress(bar->progress()+1);
|
||||
}
|
||||
void res_stack::reset() {
|
||||
cnts->reset();
|
||||
bar->setProgress(0);
|
||||
}
|
||||
void res_stack::inc_ok() { cnts->inc_ok(); inc_progress(false); }
|
||||
void res_stack::inc_fail() { cnts->inc_fail(); inc_progress(true); }
|
||||
void res_stack::inc_error() { cnts->inc_error(); inc_progress(true); }
|
||||
|
||||
QHBox* behave(QHBox* box, bool x_expand, bool y_expand)
|
||||
{
|
||||
box->setSizePolicy(QSizePolicy(
|
||||
x_expand ? QSizePolicy::Preferred : QSizePolicy::Maximum,
|
||||
y_expand ? QSizePolicy::Preferred : QSizePolicy::Maximum));
|
||||
box->setFrameShape(QFrame::StyledPanel);
|
||||
box->setFrameShadow(QFrame::Raised);
|
||||
box->setMargin(11);
|
||||
box->setSpacing(6);
|
||||
return box;
|
||||
}
|
||||
|
||||
void node::setImg()
|
||||
{
|
||||
static QPixmap i_emp((const char**)img_empty);
|
||||
static QPixmap i_ok((const char**)img_ok);
|
||||
static QPixmap i_fail((const char**)img_fail);
|
||||
static QPixmap i_err((const char**)img_error);
|
||||
static QPixmap* imgs[] = { &i_emp, &i_ok, &i_fail, &i_err };
|
||||
item->setPixmap(0, *(imgs[st]));
|
||||
if (st > is_ok)
|
||||
for (QListViewItem* ip = item; ip != 0; ip = ip->parent())
|
||||
ip->setOpen(true);
|
||||
};
|
||||
|
||||
node::node(suite_node* par, test& t)
|
||||
: item(new QListViewItem(par->lvi(), t.name().c_str())), t(t), st(none)
|
||||
{
|
||||
par->add_child(this);
|
||||
setImg();
|
||||
}
|
||||
node::node(gui* gp, test& t)
|
||||
: item(new QListViewItem(gp->test_tree(), t.name().c_str())), t(t), st(none)
|
||||
{
|
||||
setImg();
|
||||
item->setOpen(true);
|
||||
}
|
||||
void node::run()
|
||||
{
|
||||
for (QListViewItem* ip=item->firstChild(); ip != 0; ip=item->firstChild())
|
||||
delete ip;
|
||||
try {
|
||||
t();
|
||||
status(is_ok);
|
||||
emit ok();
|
||||
} catch (assertion_error& e) {
|
||||
status(is_fail);
|
||||
show_error(e);
|
||||
emit fail();
|
||||
} catch (exception& e) {
|
||||
status(is_error);
|
||||
show_error(e.what());
|
||||
emit error();
|
||||
} catch (...) {
|
||||
status(is_error);
|
||||
show_error("unknown ... exception");
|
||||
emit error();
|
||||
}
|
||||
}
|
||||
void node::show_error(assertion_error& e)
|
||||
{
|
||||
#ifdef HAVE_SSTREAM
|
||||
ostringstream oss;
|
||||
oss << e;
|
||||
show_error(oss.str().c_str());
|
||||
#else
|
||||
show_error(e.what()); // not well, but some sign
|
||||
#endif
|
||||
}
|
||||
void node::show_error(const char* msg)
|
||||
{
|
||||
QListViewItem* elvi = new QListViewItem(item, msg);
|
||||
elvi->setSelectable(false);
|
||||
}
|
||||
suite_node::suite_node(suite_node* par, suite& t) : node(par, t) { }
|
||||
suite_node::suite_node(gui* par, suite& t) : node(par, t) { }
|
||||
void suite_node::run()
|
||||
{
|
||||
status(is_ok);
|
||||
for (cctyp::iterator p = cc.begin(); p != cc.end(); ++p) {
|
||||
(*p)->run();
|
||||
status(max(status(), (*p)->status()));
|
||||
}
|
||||
switch (status()) {
|
||||
case is_ok: emit ok(); break;
|
||||
case is_fail: emit fail(); break;
|
||||
case is_error: emit error(); break;
|
||||
}
|
||||
}
|
||||
gui::gui(QApplication& app, QWidget* par, const char* name)
|
||||
: QVBox(par, name), app(app)
|
||||
{
|
||||
setMargin(6);
|
||||
setSpacing(3);
|
||||
tree = new QListView(behave(new QVBox(this), true, true), "tree");
|
||||
tree->addColumn("Test");
|
||||
tree->setFrameShadow(QListView::Sunken);
|
||||
tree->setResizePolicy(QScrollView::Manual);
|
||||
tree->setRootIsDecorated(true);
|
||||
QVBox* f_cnts = new QVBox(this);
|
||||
behave(f_cnts, true, false);
|
||||
suites = new res_stack("Suites", f_cnts);
|
||||
tests = new res_stack("Tests", f_cnts);
|
||||
QHBox* hbox = behave(new QHBox(this), true, false);
|
||||
b_run = new QPushButton("Run", hbox, "run");
|
||||
b_stop = new QPushButton("Stop", hbox, "stop");
|
||||
b_quit = new QPushButton("Quit", hbox, "quit");
|
||||
connect(b_quit, SIGNAL(clicked()), &app, SLOT(quit()));
|
||||
connect(b_run, SIGNAL(clicked()), this, SLOT(run_pressed()));
|
||||
connect(b_stop, SIGNAL(clicked()), this, SLOT(stop_pressed()));
|
||||
}
|
||||
|
||||
gui::~gui() { }
|
||||
|
||||
void gui::processEvents(int t)
|
||||
{
|
||||
app.processEvents(t);
|
||||
}
|
||||
void gui::reset()
|
||||
{
|
||||
tests->reset();
|
||||
suites->reset();
|
||||
}
|
||||
void gui::nconnect(node* n, res_stack* rs)
|
||||
{
|
||||
connect(n, SIGNAL(ok()), rs, SLOT(inc_ok()));
|
||||
connect(n, SIGNAL(fail()), rs, SLOT(inc_fail()));
|
||||
connect(n, SIGNAL(error()), rs, SLOT(inc_error()));
|
||||
}
|
||||
void gui::add_test(node* n)
|
||||
{
|
||||
nconnect(n, tests);
|
||||
}
|
||||
void gui::add_suite(node* n)
|
||||
{
|
||||
nconnect(n, suites);
|
||||
}
|
||||
|
||||
void gui::totSuites(int v) { suites->max(v); }
|
||||
void gui::totTests(int v) { tests->max(v); }
|
||||
|
||||
#endif
|
||||
166
tests/lib/unit++/gui.h
Normal file
166
tests/lib/unit++/gui.h
Normal file
@ -0,0 +1,166 @@
|
||||
#ifndef __UNITPP_GUI_H
|
||||
#define __UNITPP_GUI_H
|
||||
#ifdef GUI
|
||||
#include "tester.h"
|
||||
#include <exception>
|
||||
#include <vector>
|
||||
#include <qwidget.h>
|
||||
#include <qcolor.h>
|
||||
#include <qframe.h>
|
||||
#include <qlabel.h>
|
||||
#include <qlistview.h>
|
||||
#include <qprogressbar.h>
|
||||
#include <qhbox.h>
|
||||
#include <qvbox.h>
|
||||
#include <qpixmap.h>
|
||||
#include <qpushbutton.h>
|
||||
#include <qapplication.h>
|
||||
|
||||
/// \name unitpp
|
||||
namespace unitpp {
|
||||
/// A colored count with a unit.
|
||||
class cnt_item : public QHBox
|
||||
{
|
||||
Q_OBJECT
|
||||
private:
|
||||
int v;
|
||||
QLabel* val;
|
||||
QLabel* label;
|
||||
public:
|
||||
cnt_item(QWidget* par, const QString& txt, const QColor& col = black,
|
||||
const char* nam = 0);
|
||||
public slots:
|
||||
void value(int v);
|
||||
void inc();
|
||||
};
|
||||
|
||||
/// A line with total, ok, fail, and error counts.
|
||||
class cnt_line : public QHBox
|
||||
{
|
||||
Q_OBJECT
|
||||
private:
|
||||
enum fields { id_max, id_ok, id_fail, id_error, n_id };
|
||||
QLabel* label;
|
||||
cnt_item* cnts[n_id];
|
||||
public slots:
|
||||
void max(int v);
|
||||
void reset();
|
||||
void inc_ok();
|
||||
void inc_fail();
|
||||
void inc_error();
|
||||
public:
|
||||
cnt_line(const QString& txt, QWidget* par = 0, const char* name = 0);
|
||||
};
|
||||
|
||||
/// A cnt_line stacked with a progress bar.
|
||||
class res_stack : public QVBox
|
||||
{
|
||||
Q_OBJECT
|
||||
private:
|
||||
cnt_line* cnts;
|
||||
QProgressBar* bar;
|
||||
void inc_progress(bool red);
|
||||
public slots:
|
||||
void max(int max);
|
||||
void reset();
|
||||
void inc_ok();
|
||||
void inc_fail();
|
||||
void inc_error();
|
||||
public:
|
||||
res_stack(const QString& txt, QWidget* par=0, const char* name=0);
|
||||
};
|
||||
class node;
|
||||
/// The whole GUI box with test tree, results, and buttons.
|
||||
class gui : public QVBox
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
gui(QApplication& app, QWidget* par = 0, const char* name = 0);
|
||||
virtual ~gui();
|
||||
QListView* test_tree() { return tree; }
|
||||
void add_test(node* n);
|
||||
void add_suite(node* n);
|
||||
void processEvents(int t);
|
||||
signals:
|
||||
void run();
|
||||
void stop();
|
||||
public slots:
|
||||
void totSuites(int v);
|
||||
void totTests(int v);
|
||||
void reset();
|
||||
private slots:
|
||||
void run_pressed() { emit run(); }
|
||||
void stop_pressed() { emit stop(); }
|
||||
private:
|
||||
void nconnect(node* node, res_stack*);
|
||||
QApplication& app;
|
||||
QListView* tree;
|
||||
res_stack* suites;
|
||||
res_stack* tests;
|
||||
QPushButton* b_run;
|
||||
QPushButton* b_stop;
|
||||
QPushButton* b_quit;
|
||||
};
|
||||
class suite_node;
|
||||
// a Qt error prevents this from being a ListViewItem...
|
||||
/**
|
||||
* A node in the test tree. An error in Qt prevents this to be derived from
|
||||
* QListViewItem, hence the separation.
|
||||
*/
|
||||
class node : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
enum state { none, is_ok, is_fail, is_error };
|
||||
/// Create this node under par.
|
||||
node(suite_node* par, test&);
|
||||
/// Get the associated QListViewItem.
|
||||
QListViewItem* lvi() { return item; }
|
||||
///
|
||||
state status() { return st; }
|
||||
signals:
|
||||
/// [signal] emitted when the test succedes
|
||||
void ok();
|
||||
/// [signal] emitted when the test fails
|
||||
void fail();
|
||||
/// [signal] emitted when the test throws an exception
|
||||
void error();
|
||||
public slots:
|
||||
/// [slot] Make the test run, and emit appropriate signals.
|
||||
virtual void run();
|
||||
protected:
|
||||
/// Make a top level test, directly under the gui.
|
||||
node(gui* par, test&);
|
||||
/// Set the status of the node, including update of the displayed icon.
|
||||
void status(state s) {
|
||||
st = s;
|
||||
setImg();
|
||||
}
|
||||
private:
|
||||
void show_error(assertion_error& e);
|
||||
void show_error(const char*);
|
||||
QListViewItem* item;
|
||||
test& t;
|
||||
state st;
|
||||
void setImg();
|
||||
};
|
||||
/**
|
||||
* A specialized node representing a test suite.
|
||||
*/
|
||||
class suite_node : public node
|
||||
{
|
||||
typedef std::vector<node*> cctyp;
|
||||
cctyp cc; // child container
|
||||
public:
|
||||
/// Inner suite creation.
|
||||
suite_node(suite_node* par, suite&);
|
||||
/// Top level suite_node.
|
||||
suite_node(gui* par, suite&);
|
||||
/// Test.
|
||||
virtual void run();
|
||||
/// Register a node below this.
|
||||
void add_child(node* n) { cc.push_back(n); }
|
||||
};
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
100
tests/lib/unit++/guitester.cc
Normal file
100
tests/lib/unit++/guitester.cc
Normal file
@ -0,0 +1,100 @@
|
||||
#ifdef GUI
|
||||
#include "optmap.h"
|
||||
#include "main.h"
|
||||
#include "guitester.h"
|
||||
#include <qapplication.h>
|
||||
|
||||
using namespace unitpp;
|
||||
using namespace std;
|
||||
|
||||
class gui_test_runner : public test_runner {
|
||||
virtual bool run_tests(int argc, const char** argv)
|
||||
{
|
||||
QApplication a(argc, const_cast<char**>(argv));
|
||||
gui g(a);
|
||||
g_setup setup(&g);
|
||||
suite::main().visit(&setup);
|
||||
a.setMainWidget(&g);
|
||||
g.show();
|
||||
return a.exec();
|
||||
}
|
||||
};
|
||||
class gui_flag : public options_utils::optmap::cmd {
|
||||
bool do_cmd(options_utils::optmap* om)
|
||||
{
|
||||
static gui_test_runner gtr;
|
||||
set_tester(>r);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
gui_hook::gui_hook()
|
||||
{
|
||||
options().add("g", new gui_flag());
|
||||
options().alias("gui", "g");
|
||||
}
|
||||
|
||||
|
||||
g_setup::g_setup(gui* gp) : gp(gp), running(false), n_suites(0), n_tests(0)
|
||||
{
|
||||
connect(gp, SIGNAL(run()), this, SLOT(run()));
|
||||
}
|
||||
void g_setup::add_node(node* np)
|
||||
{
|
||||
nodes.push_back(np);
|
||||
rev[np->lvi()] = np;
|
||||
}
|
||||
void g_setup::visit(test& t)
|
||||
{
|
||||
++n_tests;
|
||||
node* np = new node(branch.top(), t);
|
||||
add_node(np);
|
||||
gp->add_test(np);
|
||||
}
|
||||
void g_setup::visit(suite& t)
|
||||
{
|
||||
++n_suites;
|
||||
suite_node* np = branch.size() ? new suite_node(branch.top(), t)
|
||||
: new suite_node(gp, t);
|
||||
branch.push(np);
|
||||
add_node(np);
|
||||
gp->add_suite(np);
|
||||
}
|
||||
void g_setup::visit(suite& t, int)
|
||||
{
|
||||
branch.pop();
|
||||
if (!branch.size()) {
|
||||
gp->totSuites(n_suites);
|
||||
gp->totTests(n_tests);
|
||||
}
|
||||
}
|
||||
|
||||
void g_setup::run()
|
||||
{
|
||||
if (running)
|
||||
return;
|
||||
running = true;
|
||||
selected.clear();
|
||||
find_selected(gp->test_tree()->firstChild());
|
||||
if (!selected.size())
|
||||
selected.push_back(rev[gp->test_tree()->firstChild()]);
|
||||
gp->reset();
|
||||
for (vector<node*>::iterator p = selected.begin(); p!=selected.end(); ++p) {
|
||||
(*p)->run();
|
||||
gp->processEvents(20);
|
||||
if (!running)
|
||||
break;
|
||||
}
|
||||
running = false;
|
||||
}
|
||||
|
||||
void g_setup::find_selected(QListViewItem* lvi)
|
||||
{
|
||||
if (!lvi)
|
||||
return;
|
||||
if (lvi->isSelected())
|
||||
selected.push_back(rev[lvi]);
|
||||
else
|
||||
find_selected(lvi->firstChild());
|
||||
find_selected(lvi->nextSibling());
|
||||
}
|
||||
#endif
|
||||
40
tests/lib/unit++/guitester.h
Normal file
40
tests/lib/unit++/guitester.h
Normal file
@ -0,0 +1,40 @@
|
||||
#ifndef __UNITPP__GUITESTER_H
|
||||
#define __UNITPP__GUITESTER_H
|
||||
#ifdef GUI
|
||||
#include "tester.h"
|
||||
#include "gui.h"
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <qobject.h>
|
||||
|
||||
/// \name unitpp
|
||||
namespace unitpp {
|
||||
/**
|
||||
* The class for setting up the GUI. It visites all the tests, and create
|
||||
* nodes for them in the test tree, count them and adjust all the GUI
|
||||
* elements appropriately.
|
||||
*/
|
||||
class g_setup : public QObject, public visitor {
|
||||
Q_OBJECT
|
||||
private:
|
||||
gui* gp;
|
||||
bool running;
|
||||
int n_suites;
|
||||
int n_tests;
|
||||
std::stack<suite_node*> branch;
|
||||
std::vector<node*> nodes, selected;
|
||||
std::map<QListViewItem*, node*> rev;
|
||||
void find_selected(QListViewItem*);
|
||||
void add_node(node* np);
|
||||
public:
|
||||
g_setup(gui* gp);
|
||||
virtual void visit(test&);
|
||||
virtual void visit(suite&);
|
||||
virtual void visit(suite&, int);
|
||||
public slots:
|
||||
///
|
||||
void run();
|
||||
};
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
69
tests/lib/unit++/main.cc
Normal file
69
tests/lib/unit++/main.cc
Normal file
@ -0,0 +1,69 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#include "main.h"
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
using namespace unitpp;
|
||||
|
||||
bool unitpp::verbose = false;
|
||||
|
||||
test_runner* runner = 0;
|
||||
|
||||
test_runner::~test_runner()
|
||||
{
|
||||
}
|
||||
|
||||
void unitpp::set_tester(test_runner* tr)
|
||||
{
|
||||
runner = tr;
|
||||
}
|
||||
|
||||
int main(int argc, const char* argv[])
|
||||
{
|
||||
options().add("v", new options_utils::opt_flag(verbose));
|
||||
options().alias("verbose", "v");
|
||||
if (!options().parse(argc, argv))
|
||||
options().usage();
|
||||
plain_runner plain;
|
||||
if (!runner)
|
||||
runner = &plain;
|
||||
return runner->run_tests(argc, argv) ? 0 : 1;
|
||||
}
|
||||
|
||||
namespace unitpp {
|
||||
options_utils::optmap& options()
|
||||
{
|
||||
static options_utils::optmap opts("[ testids... ]");
|
||||
return opts;
|
||||
}
|
||||
|
||||
bool plain_runner::run_tests(int argc, const char** argv)
|
||||
{
|
||||
bool res = true;
|
||||
if (options().n() < argc)
|
||||
for (int i = options().n(); i < argc; ++i)
|
||||
res = res && run_test(argv[i]);
|
||||
else
|
||||
res = run_test();
|
||||
return res;
|
||||
}
|
||||
|
||||
bool plain_runner::run_test(const string& id)
|
||||
{
|
||||
test* tp = suite::main().find(id);
|
||||
if (!tp) {
|
||||
return false;
|
||||
}
|
||||
return run_test(tp);
|
||||
}
|
||||
bool plain_runner::run_test(test* tp)
|
||||
{
|
||||
tester tst(cout, verbose);
|
||||
tp->visit(&tst);
|
||||
tst.summary();
|
||||
res_cnt res(tst.res_tests());
|
||||
return res.n_err() == 0 && res.n_fail() == 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
63
tests/lib/unit++/main.h
Normal file
63
tests/lib/unit++/main.h
Normal file
@ -0,0 +1,63 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#include <iostream>
|
||||
#include "tester.h"
|
||||
#include "optmap.h"
|
||||
|
||||
/**
|
||||
* The main of a test program that executes the main test suite and then
|
||||
* reports the summary.
|
||||
*
|
||||
* A #-v# or #--verbose# will turn on verbose, that reports succesful test
|
||||
* cases; the default behaviour is to report only those that fails.
|
||||
*/
|
||||
int main(int argc, const char* argv[]);
|
||||
|
||||
/// @name{unitpp}
|
||||
namespace unitpp {
|
||||
|
||||
/**
|
||||
* The verbose flag, in case somebody wants to piggyback it with more
|
||||
* meaning.
|
||||
*/
|
||||
extern bool verbose;
|
||||
|
||||
/**
|
||||
* A runner is the base class for the objects that actually processes the
|
||||
* tests from main. Main simply invokes the run_tests method of the current
|
||||
* test runner.
|
||||
* \Ref{main}
|
||||
*/
|
||||
class test_runner {
|
||||
public:
|
||||
virtual ~test_runner();
|
||||
/**
|
||||
* run all the tests with arguments in the argc, argv set
|
||||
*/
|
||||
virtual bool run_tests(int argc, const char** argv) = 0;
|
||||
};
|
||||
/**
|
||||
* Sets the test_runner to be used in testing. This hook allows another
|
||||
* tester to hook into the main function and replace the traditional tester.
|
||||
*/
|
||||
void set_tester(test_runner*);
|
||||
|
||||
/// A plain test runner for the ordinary text version.
|
||||
class plain_runner : public test_runner {
|
||||
public:
|
||||
/// Run the tests specified in argv, starting at i.
|
||||
virtual bool run_tests(int argc, const char** argv);
|
||||
private:
|
||||
/**
|
||||
* Run a test found in the suite::main() test by id. If id is empty run the
|
||||
* main test.
|
||||
* @name run_test-id
|
||||
* @return true, if the test was totally succesful.
|
||||
*/
|
||||
bool run_test(const std::string& id = "");
|
||||
/// Run the test and return true if succesful. @see{run_test-id}
|
||||
bool run_test(test*);
|
||||
/// find the test with the given id
|
||||
test* find_test(const std::string& id);
|
||||
};
|
||||
}
|
||||
4
tests/lib/unit++/optmap-compat.h
Normal file
4
tests/lib/unit++/optmap-compat.h
Normal file
@ -0,0 +1,4 @@
|
||||
// This header preserves compatibility with old unit++ versions.
|
||||
//
|
||||
// Use of this is deprecated, use unit++/optmap.h directly
|
||||
#include <unit++/optmap.h>
|
||||
145
tests/lib/unit++/optmap.cc
Normal file
145
tests/lib/unit++/optmap.cc
Normal file
@ -0,0 +1,145 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include "optmap.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace options_utils;
|
||||
|
||||
optmap::optmap(const char* usage)
|
||||
: i(1), prog("program"), tail(usage)
|
||||
{
|
||||
}
|
||||
|
||||
optmap::~optmap()
|
||||
{
|
||||
for (group_t::iterator p = group.begin(); p != group.end(); ++p)
|
||||
delete p->first;
|
||||
}
|
||||
optmap& optmap::add(const char* c, cmd* h)
|
||||
{
|
||||
if (cmds.find(c) != cmds.end())
|
||||
throw invalid_argument(string("duplicated option: ")+c);
|
||||
cmds[c] = h;
|
||||
if (group[h].size() == 0)
|
||||
gvec.push_back(h);
|
||||
group[h].push_back(c);
|
||||
return *this;
|
||||
}
|
||||
|
||||
optmap& optmap::alias(const char* new_opt, const char* old_opt)
|
||||
{
|
||||
cmd* h = cmds[old_opt];
|
||||
if (!h)
|
||||
throw invalid_argument(string("no alias: ")+old_opt);
|
||||
return add(new_opt, h);
|
||||
}
|
||||
bool optmap::parse(int c, const char** v)
|
||||
{
|
||||
argc = c;
|
||||
argv = v;
|
||||
prog = argv[0];
|
||||
for (; i < argc; ++i) {
|
||||
multichar = false;
|
||||
const char* s = argv[i];
|
||||
size_t l = strlen(s);
|
||||
if (*s != '-' || l == 1)
|
||||
return true;
|
||||
if (s[1] == '-') {
|
||||
if (l == 2) { // end of options marker `--'
|
||||
++i;
|
||||
return true;
|
||||
}
|
||||
if (!do_cmd(s+2))
|
||||
return false;
|
||||
} else {
|
||||
char cmd[2];
|
||||
cmd[1] = '\0';
|
||||
multichar = l > 2;
|
||||
first_multi = true;
|
||||
for (const char* p = s+1; *p; ++p) {
|
||||
cmd[0] = *p;
|
||||
if (!do_cmd(cmd))
|
||||
return false;;
|
||||
first_multi = false;
|
||||
if (!multichar) // get_arg used it
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
const char* optmap::get_arg()
|
||||
{
|
||||
if (multichar) {
|
||||
if (!first_multi) {
|
||||
cerr << "internal option requires argument " << argv[i] << endl;
|
||||
return 0;
|
||||
}
|
||||
multichar = false;
|
||||
return argv[i]+2;
|
||||
}
|
||||
return i < argc - 1 ? argv[++i] : 0;
|
||||
}
|
||||
|
||||
void optmap::usage(bool abort)
|
||||
{
|
||||
cerr << "usage: " << prog;
|
||||
for (gvec_t::iterator p = gvec.begin(); p != gvec.end(); ++p) {
|
||||
cmd* h = *p;
|
||||
vector<string>& v(group[h]);
|
||||
string arg = h->arg();
|
||||
bool need_par = arg.size() > 0 && v.size() > 1;
|
||||
bool first = true;
|
||||
cerr << " [";
|
||||
if (need_par)
|
||||
cerr << "(";
|
||||
for (vector<string>::iterator s = v.begin(); s != v.end(); ++s) {
|
||||
cerr << (first ? " " : " | ") << (s->size() != 1 ? "--":"-") << *s;
|
||||
first = false;
|
||||
}
|
||||
if (need_par)
|
||||
cerr << ")";
|
||||
if (arg.size())
|
||||
cerr << ' ' << arg;
|
||||
cerr << " ]";
|
||||
}
|
||||
cerr << (tail.size() ? " " : "") << tail << endl;
|
||||
if (abort)
|
||||
exit(1);
|
||||
}
|
||||
|
||||
bool optmap::do_cmd(const string& opt)
|
||||
{
|
||||
cmd* c = cmds[opt];
|
||||
if (!c) {
|
||||
cerr << "unknown option: " << opt << endl;
|
||||
return false;
|
||||
}
|
||||
return c->do_cmd(this);
|
||||
}
|
||||
|
||||
bool opt_int::do_cmd(optmap* om)
|
||||
{
|
||||
const char* arg = om->get_arg();
|
||||
if (!arg)
|
||||
return false;
|
||||
char* end;
|
||||
int v = strtol(arg, &end, 10);
|
||||
if (*end) {
|
||||
cerr << "failed to parse int argument: " << arg << endl;
|
||||
return false;
|
||||
}
|
||||
val = v;
|
||||
return true;
|
||||
}
|
||||
bool opt_string::do_cmd(optmap* om)
|
||||
{
|
||||
const char* arg = om->get_arg();
|
||||
if (!arg)
|
||||
return false;
|
||||
val = arg;
|
||||
return true;
|
||||
}
|
||||
125
tests/lib/unit++/optmap.h
Normal file
125
tests/lib/unit++/optmap.h
Normal file
@ -0,0 +1,125 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#ifndef __UNITPP__OPTMAP_H
|
||||
#define __UNITPP__OPTMAP_H
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <stdexcept>
|
||||
/**
|
||||
* The home of \Ref{optmap}. This is a unified way of handling commang line
|
||||
* arguments, and suitable usage replies when things goes badly.
|
||||
*/
|
||||
namespace options_utils {
|
||||
/**
|
||||
* A argument option handler, based on the Command pattern. Each option is
|
||||
* associated with a handling command object.
|
||||
*
|
||||
* The map keeps the reverse association as well, to allow printing of a
|
||||
* using line.
|
||||
*/
|
||||
class optmap {
|
||||
public:
|
||||
/**
|
||||
* The base for all option handlers.
|
||||
*
|
||||
* To handle a new kind of commands, just derive a class from this an
|
||||
* overload the methods to do the work.
|
||||
*/
|
||||
struct cmd {
|
||||
/**
|
||||
* Performing the work associated with the option.
|
||||
*
|
||||
* To obtain an argument see \Ref{get_arg}
|
||||
* @return true if the parsing was succesfull
|
||||
*/
|
||||
virtual bool do_cmd(optmap* om) = 0;
|
||||
/// return the name of the argument needed by \Ref{usage}
|
||||
virtual std::string arg() { return std::string(); }
|
||||
virtual ~cmd() {}
|
||||
};
|
||||
/**
|
||||
* The very simple constructor for an optmap object. Please note that
|
||||
* copying of optmaps are not supported.
|
||||
* @param usage The tail of the usage string to follow the options
|
||||
*/
|
||||
optmap(const char* usage = "");
|
||||
~optmap();
|
||||
/**
|
||||
* Adds an option that invokes the command handler.
|
||||
*
|
||||
* This is the low level work horse for all the add methods. All the
|
||||
* other adds works by adding appropriate cmd objects for doing the work.
|
||||
*
|
||||
* @param o
|
||||
* The option name. If the length of the option is 1 it will be an old
|
||||
* fashion option, otherwise it will be a GNU stype long option
|
||||
* (--long-opt).
|
||||
* @param h
|
||||
* The pointer to the handler. The optmap assumes ownership of the
|
||||
* pointer and delete it in the destructor.
|
||||
*
|
||||
* @return *this
|
||||
*/
|
||||
optmap& add(const char* o, cmd* h);
|
||||
/// Adds an alias for an option.
|
||||
optmap& alias(const char* new_opt, const char* old_opt);
|
||||
/**
|
||||
* Parse the command line.
|
||||
* @return true if the parse is valid, false otherwise.
|
||||
*/
|
||||
bool parse(int argc, const char** argv);
|
||||
/// Gets the index for the first non option argument
|
||||
int n() { return i; }
|
||||
/// display a usage string and abort()
|
||||
void usage(bool abort = true);
|
||||
/// get the argument of an option; mainly for cmd implementations.
|
||||
const char* get_arg();
|
||||
private:
|
||||
int i;
|
||||
const char* prog;
|
||||
int argc;
|
||||
const char** argv;
|
||||
bool multichar; // doing a multichar, -pdf --> -p -d -f
|
||||
bool first_multi;
|
||||
optmap(const optmap& o);
|
||||
optmap& operator=(const optmap&);
|
||||
bool do_cmd(const std::string& opt);
|
||||
std::string tail;
|
||||
typedef std::map<std::string, cmd*> cmds_t;
|
||||
cmds_t cmds;
|
||||
typedef std::vector<cmd*> gvec_t;
|
||||
gvec_t gvec;
|
||||
typedef std::map<cmd*, std::vector<std::string> > group_t;
|
||||
group_t group;
|
||||
};
|
||||
|
||||
/// A cmd handler that can set a boolean flag.
|
||||
class opt_flag : public optmap::cmd {
|
||||
bool& flg;
|
||||
public:
|
||||
/// Just give it the bool you want set if the flag is present.
|
||||
opt_flag(bool& flg) : flg(flg) {}
|
||||
virtual bool do_cmd(optmap*) { flg = true; return true; }
|
||||
};
|
||||
|
||||
/// A cmd handler that can get an integer value.
|
||||
class opt_int : public optmap::cmd {
|
||||
int& val;
|
||||
public:
|
||||
/// just give it an int variable that the flag argument can be assigned to.
|
||||
opt_int(int& val) : val(val) {}
|
||||
virtual bool do_cmd(optmap* om);
|
||||
virtual std::string arg() { return std::string("<int>"); }
|
||||
};
|
||||
/// A cmd handler for a string
|
||||
class opt_string : public optmap::cmd {
|
||||
std::string& val;
|
||||
public:
|
||||
/// Give it a string that the flag arg should be assigned to.
|
||||
opt_string(std::string& val) : val(val) {}
|
||||
virtual bool do_cmd(optmap* om);
|
||||
virtual std::string arg() { return std::string("<string>"); }
|
||||
};
|
||||
}
|
||||
#endif
|
||||
74
tests/lib/unit++/tester.cc
Normal file
74
tests/lib/unit++/tester.cc
Normal file
@ -0,0 +1,74 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#include <typeinfo>
|
||||
#include <iostream>
|
||||
#include "tester.h"
|
||||
using namespace std;
|
||||
|
||||
using namespace unitpp;
|
||||
|
||||
void tester::summary()
|
||||
{
|
||||
os << "Tests [Ok-Fail-Error]: [" << n_test.n_ok() << '-'
|
||||
<< n_test.n_fail() << '-' << n_test.n_err() << "]\n";
|
||||
}
|
||||
void tester::visit(test& t)
|
||||
{
|
||||
try {
|
||||
t();
|
||||
n_test.add_ok();
|
||||
write(t);
|
||||
} catch (assertion_error& e) {
|
||||
n_test.add_fail();
|
||||
write(t, e);
|
||||
} catch (exception& e) {
|
||||
n_test.add_err();
|
||||
write(t, e);
|
||||
} catch (...) {
|
||||
n_test.add_err();
|
||||
write(t, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void tester::visit(suite& t)
|
||||
{
|
||||
if (verbose)
|
||||
os << "****** " << t.name() << " ******" << endl;
|
||||
accu.push(n_test);
|
||||
}
|
||||
|
||||
void tester::visit(suite& , int)
|
||||
{
|
||||
res_cnt r(accu.top());
|
||||
accu.pop();
|
||||
if (n_test.n_err() != r.n_err())
|
||||
n_suite.add_err();
|
||||
else if (n_test.n_fail() != r.n_fail())
|
||||
n_suite.add_fail();
|
||||
else
|
||||
n_suite.add_ok();
|
||||
}
|
||||
void tester::write(test& t)
|
||||
{
|
||||
if (verbose)
|
||||
disp(t, "OK");
|
||||
}
|
||||
void tester::disp(test& t, const string& status)
|
||||
{
|
||||
os << status << ": " << t.name() << endl;
|
||||
}
|
||||
void tester::write(test& t, assertion_error& e)
|
||||
{
|
||||
disp(t, "FAIL");
|
||||
os << e << '\n';
|
||||
}
|
||||
void tester::write(test& t, std::exception& e)
|
||||
{
|
||||
disp(t, "ERROR");
|
||||
os << " : [" << typeid(e).name() << "] " << e.what() << '\n';
|
||||
}
|
||||
void tester::write(test& t, int )
|
||||
{
|
||||
disp(t, "ERROR");
|
||||
os << " : " << "unknown exception" << '\n';
|
||||
}
|
||||
77
tests/lib/unit++/tester.h
Normal file
77
tests/lib/unit++/tester.h
Normal file
@ -0,0 +1,77 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#ifndef _UNITPP_TESTER_H
|
||||
#define _UNITPP_TESTER_H
|
||||
#include <stack>
|
||||
#ifdef __UNITPP
|
||||
#include "unit++.h"
|
||||
#else
|
||||
#include <unit++/unit++.h>
|
||||
#endif
|
||||
namespace unitpp {
|
||||
/// A mostly internal class for keeping score.
|
||||
class res_cnt {
|
||||
int ok, fail, err;
|
||||
public:
|
||||
/// Create a 0 count.
|
||||
res_cnt() : ok(0), fail(0), err(0) {}
|
||||
/// Count one ok.
|
||||
void add_ok() { ++ok; }
|
||||
/// Count one fail.
|
||||
void add_fail() { ++fail; }
|
||||
/// Count one error.
|
||||
void add_err() { ++err; }
|
||||
/// get ok count.
|
||||
int n_ok() { return ok; }
|
||||
/// get fail count.
|
||||
int n_fail() { return fail; }
|
||||
/// get error count.
|
||||
int n_err() { return err; }
|
||||
/// get total count.
|
||||
int n() { return ok+fail+err; }
|
||||
};
|
||||
/**
|
||||
* The standard text based tester. It implements the visitor pattern for the
|
||||
* test and suite classes, and executes each test case in a depth first
|
||||
* traversal, toting the score of test cases.
|
||||
*
|
||||
* The class might be used for test executers aimed at other environments,
|
||||
* e.g. a GUI based version.
|
||||
*
|
||||
* Please note that this class is automagically instantiated by the main
|
||||
* method supplied in the library. This means that you might very well do all
|
||||
* your testing without directly laying hans on this fellow.
|
||||
*/
|
||||
class tester : public visitor {
|
||||
std::ostream& os;
|
||||
bool verbose; // list succeded tests
|
||||
std::stack<res_cnt> accu;
|
||||
res_cnt n_suite, n_test;
|
||||
void disp(test& t, const std::string&);
|
||||
void write(test& t);
|
||||
void write(test& t, assertion_error& e);
|
||||
void write(test& t, std::exception& e);
|
||||
void write(test& t, int dummy);
|
||||
public:
|
||||
/**
|
||||
* Create a text tester.
|
||||
* \param os the stream to write results to.
|
||||
* \param verbose whether to report on succesful tests
|
||||
*/
|
||||
tester(std::ostream& os, bool verbose = false) : os(os), verbose(verbose) {}
|
||||
/// Get the score for tests
|
||||
res_cnt res_tests() { return n_test; }
|
||||
/// Get the score for suites
|
||||
res_cnt res_suites() { return n_suite; }
|
||||
/// Write the summary
|
||||
virtual void summary();
|
||||
/// Part of the visitor pattern.
|
||||
virtual void visit(test&);
|
||||
/// Part of the visitor pattern.
|
||||
virtual void visit(suite&);
|
||||
/// Part of the visitor pattern; visit to suite after children.
|
||||
virtual void visit(suite& t, int);
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
4
tests/lib/unit++/unit++-compat.h
Normal file
4
tests/lib/unit++/unit++-compat.h
Normal file
@ -0,0 +1,4 @@
|
||||
// This header preserves compatibility with old unit++ versions.
|
||||
//
|
||||
// Use of this is deprecated, use unit++/unit++.h directly
|
||||
#include <unit++/unit++.h>
|
||||
27
tests/lib/unit++/unit++.1
Normal file
27
tests/lib/unit++/unit++.1
Normal file
@ -0,0 +1,27 @@
|
||||
.hy 0
|
||||
.if n .na
|
||||
.TH UNIT++ 1 2002-02-23 "Unit++ 1.2"
|
||||
.UC
|
||||
.SH NAME
|
||||
\fBunit++\fB \- run a set of tests
|
||||
.SH SYNOPSIS
|
||||
.BI "unit++ [-v|--verbose] [-g|--gui] [testid...]
|
||||
.SH DESCRIPTION
|
||||
.B unit++
|
||||
(the usual name) is the resulting program from compiling a set of unit++
|
||||
tests, and linking them with the
|
||||
.B unit++(3)
|
||||
library supplied main function to obtain an executable test suite.
|
||||
|
||||
Each test in the test tree has an id, and it is possible to start only some
|
||||
of the tests by naming them in the form id1.id2.id3.
|
||||
|
||||
The GUI option is only available if the library was compiled with GUI
|
||||
support, and the tests has actually linked the GUI stuff as well. Otherwise
|
||||
the -g option will provoke an error. Otherwise it will give a Qt based GUI
|
||||
that allows running of individual tests, with a nice green (or less nice red)
|
||||
bar that shows success (or failure).
|
||||
.SH AUTHOR
|
||||
Claus Dræby <azhrarn@users.sourceforge.net>
|
||||
.SH SEE ALSO
|
||||
.BR unit++ (3).
|
||||
130
tests/lib/unit++/unit++.3
Normal file
130
tests/lib/unit++/unit++.3
Normal file
@ -0,0 +1,130 @@
|
||||
.hy 0
|
||||
.if n .na
|
||||
.TH UNIT++ 3 2002-02-23 "Unit++ 1.2"
|
||||
.UC
|
||||
.SH NAME
|
||||
\fBunit++\fB: \fBtest\fB, \fBsuite\fb, \fBtestcase\fB \- test framework for C++.
|
||||
.SH SYNOPSIS
|
||||
.B #include <unit++/unit++.h>
|
||||
.br
|
||||
.B using namespace unitpp;
|
||||
.br
|
||||
.B using namespace std;
|
||||
.sp
|
||||
.BI "test::test(string " name );
|
||||
.sp
|
||||
.B virtual void test::operator()();
|
||||
.sp
|
||||
.B class suite : public test
|
||||
.sp
|
||||
.BI "suite::suite(string " name );
|
||||
.sp
|
||||
.BI "static suite& suite::main();"
|
||||
.sp
|
||||
.BI "void suite::add(const string& " id ", const testcase& " t );
|
||||
.sp
|
||||
.BI "template<typename " C "> "
|
||||
.br
|
||||
.BI " testcase::testcase(" C "* " par ", const string& " name ", "
|
||||
.br
|
||||
.BI " typename test_mfun<" C ">::mfp " fp ");"
|
||||
.sp
|
||||
.BI "testcase::testcase(test* " t );
|
||||
.sp
|
||||
.BI "fail(const string& " msg );
|
||||
.sp
|
||||
.BI "template<typename " A "> "
|
||||
.br
|
||||
.BI " void assert_true(const string& " msg ", " A " " assertion );
|
||||
.sp
|
||||
.BI "template<typename " T1 ", typename " T2 "> "
|
||||
.br
|
||||
.BI " void assert_eq(const string& " msg ", " T1 " " exp ", " T2 " " got );
|
||||
.sp
|
||||
.BI "gui_hook::gui_hook();"
|
||||
.SH LIBRARIES
|
||||
.B -lunit++
|
||||
.SH DESCRIPTION
|
||||
.B unit++
|
||||
is a fremework that allows creation and execution of C++ unit tests. Each
|
||||
test is an instance of the
|
||||
.B test
|
||||
class, and is managed by an instance of the
|
||||
.B testcase
|
||||
class. The actual takes place by invoking each test as function, that is
|
||||
calling the virtual operator(). However, the usual way of making tests is by
|
||||
using a class derived from the
|
||||
.B suite
|
||||
class to wrap a number of releated tests, Each test then
|
||||
becomes a member function in the class, and the testcase instance is
|
||||
constructed by using the
|
||||
.B member function template constructor.
|
||||
|
||||
Each test suite class is usually placed in an anonymous namespace to allow
|
||||
the all to be named Test, as in the example below. Since the
|
||||
.B main
|
||||
method of the library runs a global test suite each suite must add itself to
|
||||
this global tree. This is done by invoking
|
||||
.B add
|
||||
on the test suite object obtained by
|
||||
.B suite::main().
|
||||
|
||||
The assert templates allows the tests to check conditions;
|
||||
.B assert_true
|
||||
checks a truth value, that is it fails if !
|
||||
.I assertion
|
||||
evaluates to true;
|
||||
.B assert_eq asserts equality by use of == between two objects, both of which
|
||||
must be of types that can be written to a stream by use of <<.
|
||||
.B fail
|
||||
simply fails a test.
|
||||
|
||||
The
|
||||
.B gui_hook
|
||||
class is the hook for allowing a test to use the Qt gui for the test program.
|
||||
A test program must have exactly one global object of type gui_hook in order
|
||||
to enable the gui, Even when compiled without gui support, creating a
|
||||
gui_hook is ok, but it will only have effect if gui support was enabled when
|
||||
the library was compiled.
|
||||
.SH EXAMPLES
|
||||
.nf
|
||||
#include <unit++/unit++.h>
|
||||
using namespace std;
|
||||
using namespace unitpp;
|
||||
namespace {
|
||||
class Test : public suite
|
||||
{
|
||||
char* p = "Hej";
|
||||
string s("mor");
|
||||
void t1()
|
||||
{
|
||||
assert_true("pointer is not 0", p);
|
||||
}
|
||||
void t2()
|
||||
{
|
||||
assert_eq("Texts match", string("Mor"), s);
|
||||
}
|
||||
public:
|
||||
Test() : suite("Yet another test suite")
|
||||
{
|
||||
suite::main().add("demo", this);
|
||||
add("t1", testcase(this, "T1", &Test::t1));
|
||||
add("t2", testcase(this, "T2", &Test::t2));
|
||||
}
|
||||
} * theTest = new Test();
|
||||
}
|
||||
.fi
|
||||
.SH NOTE
|
||||
Each test suite runs all its tests in the same instance. That means that the
|
||||
above example will invoke first t1 and then t2 in the same object. Hence any
|
||||
side effects on the Test object that a test function has survives to the
|
||||
subsequent tests in the same object. This behaviour is directly opposite to
|
||||
how the original unit test framework junit treats test suites. There are
|
||||
however compelling C++ reasons why it must be so, and once known it might
|
||||
even be used to an advantage from time to time.
|
||||
.SH AUTHOR
|
||||
|
||||
Claus Dræby <azhrarn@users.sourceforge.net>
|
||||
|
||||
.SH SEE ALSO
|
||||
.BR unit++ (1).
|
||||
93
tests/lib/unit++/unit++.cc
Normal file
93
tests/lib/unit++/unit++.cc
Normal file
@ -0,0 +1,93 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include "unit++.h"
|
||||
|
||||
using namespace unitpp;
|
||||
using namespace std;
|
||||
|
||||
#ifndef GUI
|
||||
gui_hook::gui_hook() { }
|
||||
#endif
|
||||
void test::visit(visitor* v)
|
||||
{
|
||||
v->visit(*this);
|
||||
}
|
||||
testcase::testcase(test* t)
|
||||
: cnt(new size_t(1)), tst(t)
|
||||
{
|
||||
}
|
||||
testcase::testcase(const testcase& t)
|
||||
: cnt(t.cnt), tst(t.tst)
|
||||
{
|
||||
(*cnt)++;
|
||||
}
|
||||
void testcase::dec_cnt()
|
||||
{
|
||||
if (--(*cnt) == 0) {
|
||||
delete cnt;
|
||||
delete tst;
|
||||
}
|
||||
}
|
||||
testcase::~testcase()
|
||||
{
|
||||
dec_cnt();
|
||||
}
|
||||
testcase& testcase::operator=(const testcase& t)
|
||||
{
|
||||
++*(t.cnt);
|
||||
dec_cnt();
|
||||
cnt = t.cnt;
|
||||
tst = t.tst;
|
||||
return *this;
|
||||
}
|
||||
suite& suite::main()
|
||||
{
|
||||
static suite instance("top");
|
||||
return instance;
|
||||
}
|
||||
test* suite::get_child(const string& id)
|
||||
{
|
||||
vector<string>::iterator p = std::find(ids.begin(), ids.end(), id);
|
||||
if (p != ids.end())
|
||||
return &(static_cast<test&>(tests[p - ids.begin()]));
|
||||
return 0;
|
||||
}
|
||||
vector<string> unitpp::vectorize(const string& str, char c)
|
||||
{
|
||||
vector<string> res;
|
||||
string::const_iterator s, p;
|
||||
for (s = str.begin(); s != str.end(); ) {
|
||||
p = find(s, str.end(), c);
|
||||
res.push_back(string(s, p));
|
||||
s = (p == str.end()) ? p : p + 1;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
test* suite::find(const string& id)
|
||||
{
|
||||
vector<string> ss(vectorize(id, '.'));
|
||||
test* tp = this;
|
||||
for (vector<string>::iterator p = ss.begin(); p != ss.end(); ++p)
|
||||
if (!(tp = tp->get_child(*p)))
|
||||
break;
|
||||
return tp;
|
||||
}
|
||||
void suite::add(const string& id, const testcase& t)
|
||||
{
|
||||
ids.push_back(id);
|
||||
tests.push_back(t);
|
||||
}
|
||||
void suite::visit(visitor* v)
|
||||
{
|
||||
v->visit(*this);
|
||||
for_each(tests.begin(), tests.end(),
|
||||
bind2nd(mem_fun_ref(&testcase::visit), v));
|
||||
v->visit(*this, 0);
|
||||
}
|
||||
|
||||
void unitpp::assertion_error::out(ostream& os) const
|
||||
{
|
||||
os << msg << string(" [assertion failed]");
|
||||
}
|
||||
344
tests/lib/unit++/unit++.h
Normal file
344
tests/lib/unit++/unit++.h
Normal file
@ -0,0 +1,344 @@
|
||||
// Copyright (C) 2001 Claus Dræby
|
||||
// Terms of use are in the file COPYING
|
||||
#ifndef __TEST_FW_H_
|
||||
#define __TEST_FW_H_
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <iostream>
|
||||
#include "optmap.h"
|
||||
/**
|
||||
* The unitpp name space holds all the stuff needed to use the unit++ testing
|
||||
* framework.
|
||||
*
|
||||
* The normal way to make a test is like this:
|
||||
*
|
||||
\begin{verbatim}
|
||||
#include<unit++/unit++.h>
|
||||
using namespace unitpp;
|
||||
// use anonymous namespace so all test classes can be named Test
|
||||
namespace {
|
||||
class Test : public suite {
|
||||
void test1()
|
||||
{
|
||||
// do test stuff
|
||||
assert_true("message", exp1); // exp1 should be true
|
||||
assert_eq("another msg", 123456, exp2); // exp2 should be 123456
|
||||
// ...
|
||||
}
|
||||
void test2()
|
||||
{
|
||||
// do something that provokes exception out_of_range
|
||||
}
|
||||
public:
|
||||
Test() : suite("appropriate name for test suite")
|
||||
{
|
||||
// any setup you need
|
||||
add("id1", testcase(this, "Test 1", &Test::test1));
|
||||
// make a testcase from the method
|
||||
testcase tc(this, "Test 2", &Test::test2);
|
||||
// add a testcase that expects the exception
|
||||
add("id2", exception_case<out_of_range>(tc));
|
||||
// add the suite to the global test suite
|
||||
suite::main().add("id", this);
|
||||
}
|
||||
} * theTest = new Test(); // by new, since testcase claims ownership
|
||||
}
|
||||
\end{verbatim}
|
||||
*
|
||||
* In order to make an executable test, simply link the above code against
|
||||
* libunit++, something like
|
||||
*
|
||||
* #g++ -o test++ mytest.cc -L <location of libunit++> -lunit++#
|
||||
*
|
||||
* This will generate a test called #test++# and the standard behaviour for a
|
||||
* test. Note that most shells have #test# defined as a shell builtin which
|
||||
* makes it a moderately bad name for a program, since it is rather hard to
|
||||
* get executed, hence #test++#.
|
||||
* @see main
|
||||
*/
|
||||
namespace unitpp {
|
||||
|
||||
class visitor;
|
||||
/**
|
||||
* The heart of a test system: A test. The test is meant as a base class for
|
||||
* the tests that a client want performed. This means that all tests are to
|
||||
* be pointers dynamically allocated. However, the test system takes
|
||||
* responsibilities for freeing them again.
|
||||
*
|
||||
* The function call overload mechanism is used for the executable part of
|
||||
* the test.
|
||||
*/
|
||||
class test {
|
||||
std::string nam;
|
||||
public:
|
||||
/// A test just needs a name
|
||||
test(const std::string& name) : nam(name) {}
|
||||
virtual ~test() {}
|
||||
/// The execution of the test
|
||||
virtual void operator()() = 0;
|
||||
virtual void visit(visitor*);
|
||||
virtual test* get_child(const std::string&) { return 0; }
|
||||
std::string name() const { return nam; }
|
||||
};
|
||||
|
||||
/**
|
||||
* A test that is implemented by a member function.
|
||||
*/
|
||||
template<typename C>
|
||||
class test_mfun : public test {
|
||||
public:
|
||||
typedef void (C::*mfp)();
|
||||
/// An object, a name, and a pointer to a member function.
|
||||
test_mfun(C* par, const std::string& name, mfp fp)
|
||||
: test(name), par(par), fp(fp)
|
||||
{}
|
||||
/// Executed by invoking the function in the object.
|
||||
virtual void operator()()
|
||||
{
|
||||
(par->*fp)();
|
||||
}
|
||||
private:
|
||||
C* par;
|
||||
mfp fp;
|
||||
};
|
||||
|
||||
/**
|
||||
* A ref counted reference to a test. This is what test suites are composed
|
||||
* of, and what ensures destruction.
|
||||
*/
|
||||
class testcase {
|
||||
size_t* cnt;
|
||||
test* tst;
|
||||
void dec_cnt();
|
||||
public:
|
||||
/// Simply wrap -- and own -- a test.
|
||||
testcase(test* t);
|
||||
/// Keep the ref count
|
||||
testcase(const testcase& tr);
|
||||
/**
|
||||
* Make a testcase from a class and a member function.
|
||||
*
|
||||
* The normal usage is inside some test suite class Test:
|
||||
*
|
||||
* #add("id", testcase(this, "Testing this and that", &Test::test))#
|
||||
*
|
||||
* to make a test that invokes the test method on the instance of the
|
||||
* suite class.
|
||||
* \Ref{test_mfun}
|
||||
*/
|
||||
template<typename C>
|
||||
testcase(C* par, const std::string& name, typename test_mfun<C>::mfp fp)
|
||||
: cnt(new size_t(1)), tst(new test_mfun<C>(par, name, fp))
|
||||
{ }
|
||||
~testcase();
|
||||
/// Assignment that maintains reference count.
|
||||
testcase& operator=(const testcase&);
|
||||
void visit(visitor* vp) const { tst->visit(vp); }
|
||||
operator test& () { return *tst; }
|
||||
operator const test& () const { return *tst; }
|
||||
};
|
||||
|
||||
/**
|
||||
* A wrapper class for the testcase class that succedes if the correct
|
||||
* exception is generated.
|
||||
*/
|
||||
template<typename E>
|
||||
class exception_test : public test {
|
||||
public:
|
||||
/**
|
||||
* The constructor needs a testcase to wrap. This exception_test will
|
||||
* fail unless the wrapped testcase generates the exception.
|
||||
*
|
||||
* The name of the exception_test is copied from the wrapped test.
|
||||
*/
|
||||
exception_test(const testcase& tc)
|
||||
: test(static_cast<const test&>(tc).name()), tc(tc) {}
|
||||
~exception_test() {}
|
||||
/// Runs the wrapped test, and fails unless the correct exception is thrown.
|
||||
virtual void operator()();
|
||||
private:
|
||||
testcase tc;
|
||||
};
|
||||
/**
|
||||
* Generate a testcase that expects a specific exception from the testcase it
|
||||
* wraps. It can be used something like
|
||||
*
|
||||
* #testcase tc(this, "Test name", &Test::test);#
|
||||
*
|
||||
* #add("ex", exception_case<out_of_range>(tc));#
|
||||
*
|
||||
* The name of the exception_case is copied from the wrapped testcase, and
|
||||
* the exception_case will execute the tc test case and report a failure
|
||||
* unless the #out_of_range# exception is generated.
|
||||
*/
|
||||
template<typename E>
|
||||
testcase exception_case(const testcase& tc)
|
||||
{
|
||||
return testcase(new exception_test<E>(tc));
|
||||
}
|
||||
|
||||
/**
|
||||
* Splits the string by char c. Each c will generate a new element in the
|
||||
* vector, including leading and trailing c.
|
||||
*/
|
||||
extern std::vector<std::string> vectorize(const std::string& str, char c);
|
||||
|
||||
/**
|
||||
* A suite is a test that happens to be a collection of tests. This is an
|
||||
* implementation of the Composite pattern.
|
||||
*/
|
||||
class suite : public test {
|
||||
std::vector<std::string> ids;
|
||||
std::vector<testcase> tests;
|
||||
public:
|
||||
/// Make an empty test suite.
|
||||
suite(const std::string& name) : test(name) {}
|
||||
virtual ~suite() {};
|
||||
/// Add a testcase to the suite.
|
||||
void add(const std::string& id, const testcase& t);
|
||||
/**
|
||||
* Get a child with the specified id.
|
||||
* @return 0 if not found.
|
||||
*/
|
||||
virtual test* get_child(const std::string& id);
|
||||
/// An empty implementation.
|
||||
virtual void operator()() {}
|
||||
/// Allow a visitor to visit a suite node of the test tree.
|
||||
void visit(visitor*);
|
||||
/// Get a reference to the main test suite that the main program will run.
|
||||
static suite& main();
|
||||
// Splits the string by dots, and use each id to find a suite or test.
|
||||
test* find(const std::string& id);
|
||||
};
|
||||
|
||||
/**
|
||||
* The visitor class is a base class for classes that wants to participate in
|
||||
* the visitor pattern with the test hierarchi.
|
||||
*
|
||||
* This is a slightly extended visitor pattern implementation, intended for
|
||||
* collaboration with the Composite pattern. The aggregate node (here the
|
||||
* suite node) is visited twice, before and after the children are visited.
|
||||
* This allows different algorithms to be implemented.
|
||||
*/
|
||||
class visitor {
|
||||
public:
|
||||
virtual ~visitor() {}
|
||||
/// Visit a test case, that is not a suite.
|
||||
virtual void visit(test&) = 0;
|
||||
/// Visit a suite node before the children are visited.
|
||||
virtual void visit(suite&) {};
|
||||
/**
|
||||
* Visit a suite after the children are visited
|
||||
*/
|
||||
virtual void visit(suite&, int dummy) = 0; // post childs
|
||||
};
|
||||
|
||||
/// The basic for all failed assert statements.
|
||||
class assertion_error : public std::exception
|
||||
{
|
||||
std::string msg;
|
||||
public:
|
||||
/// An assertion error with the given message.
|
||||
assertion_error(const std::string& msg) : msg(msg) {}
|
||||
///
|
||||
std::string message() const { return msg; }
|
||||
virtual ~assertion_error() throw () {}
|
||||
/**
|
||||
* The virtual method used for operator<<.
|
||||
*/
|
||||
virtual void out(std::ostream& os) const;
|
||||
};
|
||||
/**
|
||||
* This exception represents a failed comparison between two values of types
|
||||
* T1 and T2. Both the expected and the actually value are kept.
|
||||
*/
|
||||
template<class T1, class T2>
|
||||
class assert_value_error : public assertion_error
|
||||
{
|
||||
T1 exp;
|
||||
T2 got;
|
||||
public:
|
||||
/// Construct by message, expected and gotten.
|
||||
assert_value_error(const std::string& msg, T1& exp, T2& got)
|
||||
: assertion_error(msg), exp(exp), got(got)
|
||||
{
|
||||
}
|
||||
virtual ~assert_value_error() throw () {}
|
||||
/**
|
||||
* Specialized version that requires both T1 and T2 to support
|
||||
* operator<<(ostream&, Tn).
|
||||
*/
|
||||
virtual void out(std::ostream& os) const
|
||||
{
|
||||
os << message() << " [expected: `" << exp << "' got: `" << got << "']";
|
||||
}
|
||||
};
|
||||
/// The test was not succesful.
|
||||
inline void fail(const std::string& msg)
|
||||
{
|
||||
throw assertion_error(msg);
|
||||
}
|
||||
template<typename E>
|
||||
void exception_test<E>::operator()()
|
||||
{
|
||||
try {
|
||||
(static_cast<test&>(tc))();
|
||||
fail("unexpected lack of exception");
|
||||
} catch (E& ) {
|
||||
// fine!
|
||||
}
|
||||
}
|
||||
/// Assert that the assertion is true, that is fail #if (!assertion) ...#
|
||||
template<class A> inline void assert_true(const std::string& msg, A assertion)
|
||||
{
|
||||
if (!assertion)
|
||||
throw assertion_error(msg);
|
||||
}
|
||||
/// Assert that the two arguments are equal in the #==# sense.
|
||||
template<class T1, class T2>
|
||||
inline void assert_eq(const std::string& msg, T1 exp, T2 got)
|
||||
{
|
||||
if (!(exp == got))
|
||||
throw assert_value_error<T1,T2>(msg, exp, got);
|
||||
}
|
||||
/*
|
||||
* Put an assertion error to a stream, using the out method. The out method
|
||||
* is virtual.
|
||||
*/
|
||||
inline std::ostream& operator<<(std::ostream& os, const unitpp::assertion_error& a)
|
||||
{
|
||||
a.out(os);
|
||||
return os;
|
||||
}
|
||||
|
||||
/**
|
||||
* The singleton instance of the option handler of main.
|
||||
*
|
||||
* This allows a test to add its own flags to the resulting test program, in
|
||||
* the following way.
|
||||
*
|
||||
* #bool x_flg = false;#
|
||||
* #unitpp::options().add("x", new options_utils::opt_flag(x_flg));#
|
||||
*
|
||||
* If a -x is now given to the resulting test it will set the #x_flg#
|
||||
* variable;
|
||||
*/
|
||||
options_utils::optmap& options();
|
||||
|
||||
/**
|
||||
* An instance of this class hooks the GUI code into the test executable.
|
||||
* Hence, make a global variable of class gui_hook to allow the -g option to
|
||||
* a test.
|
||||
*
|
||||
* If the library is compiled without GUI support, it is still legal to
|
||||
* create an instance of gui_hook, but it will not add the -g option.
|
||||
*/
|
||||
class gui_hook {
|
||||
public:
|
||||
gui_hook();
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
59
tests/lib/unit++/unitpp.m4
Normal file
59
tests/lib/unit++/unitpp.m4
Normal file
@ -0,0 +1,59 @@
|
||||
dnl AM_PATH_UNITPP([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
|
||||
dnl note to self - reference vars with $1, $2 etc
|
||||
|
||||
AC_DEFUN(AM_PATH_UNITPP,
|
||||
[
|
||||
AC_LANG_PUSH(C++)
|
||||
|
||||
AC_ARG_ENABLE(unitpp,
|
||||
AC_HELP_STRING([--enable-unitpp-test],
|
||||
[enable unit tests (default is YES if you have libunit++, else NO)]),
|
||||
,
|
||||
[enable_unitpp="yes"] )
|
||||
|
||||
AC_ARG_WITH(unitpp-prefix,
|
||||
AC_HELP_STRING([--with-unitpp-prefix=DIR],
|
||||
[specify the location of unit++ for unit tests]) )
|
||||
|
||||
if test "x$with_unitpp_prefix"="x"; then
|
||||
UNITPP_CXXFLAGS="-I$with_unitpp_prefix/include"
|
||||
UNITPP_LIBS="-L$with_unitpp_prefix/lib -lunit++"
|
||||
else
|
||||
# UNITPP_CXXFLAGS="-I/usr/local/include"
|
||||
UNITPP_LIBS="-lunit++"
|
||||
fi
|
||||
CXXFLAGS="$CXXFLAGS $UNITPP_CXXFLAGS"
|
||||
LIBS="$LIBS $UNITPP_LIBS"
|
||||
|
||||
if test $enable_unitpp="yes"; then
|
||||
AC_CHECK_HEADER(unit++/unit++.h,
|
||||
[ac_check_unitpp="yes"],
|
||||
[ac_check_unitpp="no"] )
|
||||
|
||||
if test $ac_check_unitpp="yes"; then
|
||||
AC_MSG_CHECKING(if unit++ test program compiles)
|
||||
AC_TRY_LINK(
|
||||
[ #include<unit++/unit++.h> ],
|
||||
[ unitpp::test* test_test = new unitpp::suite("Test Suite"); ],
|
||||
[ac_check_unitpp="yes"
|
||||
AC_MSG_RESULT(yes) ],
|
||||
[ac_check_unitpp="no"
|
||||
AC_MSG_RESULT(no) ] )
|
||||
fi
|
||||
else
|
||||
ac_check_unitpp="yes"
|
||||
fi
|
||||
|
||||
if test $ac_check_unitpp="yes"; then
|
||||
ifelse([$1], , :, [$1])
|
||||
else
|
||||
UNITPP_CXXFLAGS=""
|
||||
UNITPP_LIBS=""
|
||||
ifelse([$2], , :, [$2])
|
||||
fi
|
||||
|
||||
AC_LANG_POP(C++)
|
||||
|
||||
AC_SUBST(UNITPP_CXXFLAGS)
|
||||
AC_SUBST(UNITPP_LIBS)
|
||||
])
|
||||
4
tests/parser/Makefile
Normal file
4
tests/parser/Makefile
Normal file
@ -0,0 +1,4 @@
|
||||
|
||||
main: headerTest.cpp ../../libvmime-debug.a
|
||||
g++ -o headerTest headerTest.cpp ../../libvmime-debug.a ../lib/unit++/unit++.cc ../lib/unit++/main.cc ../lib/unit++/optmap.cc ../lib/unit++/tester.cc -Wall
|
||||
|
||||
101
tests/parser/headerTest.cpp
Normal file
101
tests/parser/headerTest.cpp
Normal file
@ -0,0 +1,101 @@
|
||||
#include "../lib/unit++/unit++.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <ostream>
|
||||
|
||||
#include "../../src/vmime"
|
||||
#include "../../examples/common.inc"
|
||||
|
||||
using namespace unitpp;
|
||||
|
||||
namespace
|
||||
{
|
||||
class headerTest : public suite
|
||||
{
|
||||
static const std::string getFieldValue(const vmime::headerField& field)
|
||||
{
|
||||
std::ostringstream oss;
|
||||
vmime::utility::outputStreamAdapter voss(oss);
|
||||
field.generate(voss);
|
||||
|
||||
return (oss.str());
|
||||
}
|
||||
|
||||
// getAllByType function tests
|
||||
void testGetAllByType1()
|
||||
{
|
||||
vmime::header hdr;
|
||||
hdr.parse("To: a\r\nFrom: b\r\n");
|
||||
|
||||
std::vector <vmime::headerField*> res = hdr.fields.findAllByType(vmime::headerField::Subject);
|
||||
|
||||
assert_eq("Count", (unsigned int) 0, res.size());
|
||||
}
|
||||
|
||||
void testGetAllByType2()
|
||||
{
|
||||
vmime::header hdr;
|
||||
hdr.parse("To: b\r\nTo : a\r\nFrom: c\r\n");
|
||||
|
||||
std::vector <vmime::headerField*> res = hdr.fields.findAllByType(vmime::headerField::To);
|
||||
|
||||
assert_eq("Count", (unsigned int) 2, res.size());
|
||||
assert_eq("First value", "To: b", headerTest::getFieldValue(*res[0]));
|
||||
assert_eq("First value", "To: a", headerTest::getFieldValue(*res[1]));
|
||||
}
|
||||
|
||||
// getAllByName function tests
|
||||
void testGetAllByName1()
|
||||
{
|
||||
vmime::header hdr;
|
||||
hdr.parse("A: a1\nC: c1\n");
|
||||
|
||||
std::vector <vmime::headerField*> res = hdr.fields.findAllByName("B");
|
||||
|
||||
assert_eq("Count", (unsigned int) 0, res.size());
|
||||
}
|
||||
|
||||
void testGetAllByName2()
|
||||
{
|
||||
vmime::header hdr;
|
||||
hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\n");
|
||||
|
||||
std::vector <vmime::headerField*> res = hdr.fields.findAllByName("B");
|
||||
|
||||
assert_eq("Count", (unsigned int) 2, res.size());
|
||||
assert_eq("First value", "B: b1", headerTest::getFieldValue(*res[0]));
|
||||
assert_eq("Second value", "B: b2", headerTest::getFieldValue(*res[1]));
|
||||
}
|
||||
|
||||
void testGetAllByName3()
|
||||
{
|
||||
vmime::header hdr;
|
||||
hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\nC: c3\nC: c2\n");
|
||||
|
||||
std::vector <vmime::headerField*> res = hdr.fields.findAllByName("C");
|
||||
|
||||
assert_eq("Count", (unsigned int) 3, res.size());
|
||||
assert_eq("First value", "C: c1", headerTest::getFieldValue(*res[0]));
|
||||
assert_eq("Second value", "C: c3", headerTest::getFieldValue(*res[1]));
|
||||
assert_eq("Second value", "C: c2", headerTest::getFieldValue(*res[2]));
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
headerTest() : suite("vmime::header")
|
||||
{
|
||||
// VMime initialization
|
||||
vmime::platformDependant::setHandler<my_handler>();
|
||||
|
||||
add("GetAllByType", testcase(this, "GetAllByType1", &headerTest::testGetAllByType1));
|
||||
add("GetAllByType", testcase(this, "GetAllByType2", &headerTest::testGetAllByType2));
|
||||
add("GetAllByName", testcase(this, "GetAllByName1", &headerTest::testGetAllByName1));
|
||||
add("GetAllByName", testcase(this, "GetAllByName2", &headerTest::testGetAllByName2));
|
||||
add("GetAllByName", testcase(this, "GetAllByName3", &headerTest::testGetAllByName3));
|
||||
suite::main().add("vmime::header", this);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
headerTest* theTest = new headerTest();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user