Index: ChangeLog from Damien Thivolle <damien@lrde.epita.fr> * tests/main/tests/pow2sup1: New. * tests/main/tests/pow2sup2: New. * tests/array: New. * tests/array/test_array1d.cc: New. * tests/array/test_array2d.cc: New. * tests/array/gen_test_utils: New. * tests/array/gen_test_utils/postlude: New. * tests/array/gen_test_utils/errors.cc: New. * tests/array/gen_test_utils/prelude: New. * tests/array/gen_test_utils/errors.hh: New. * tests/array/test_array3d.cc: New. * tests/array/Makefile.am: New. * tests/array/gen_test.cc: New. array/Makefile.am | 18 ++ array/gen_test.cc | 346 +++++++++++++++++++++++++++++++++++++++++ array/gen_test_utils/errors.cc | 290 ++++++++++++++++++++++++++++++++++ array/gen_test_utils/errors.hh | 22 ++ array/gen_test_utils/postlude | 8 array/gen_test_utils/prelude | 20 ++ array/test_array1d.cc | 31 +++ array/test_array2d.cc | 35 ++++ array/test_array3d.cc | 44 +++++ main/tests/pow2sup1 | 37 ++++ main/tests/pow2sup2 | 37 ++++ 11 files changed, 888 insertions(+) Index: tests/main/tests/pow2sup1 --- tests/main/tests/pow2sup1 (revision 0) +++ tests/main/tests/pow2sup1 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library 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 library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#include <mlc/math.hh> + +using namespace mlc; + +int main() +{ + const int i = pow2sup<33>::value; // COMPFAIL + return i; +} Index: tests/main/tests/pow2sup2 --- tests/main/tests/pow2sup2 (revision 0) +++ tests/main/tests/pow2sup2 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library 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 library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#include <mlc/math.hh> + +using namespace mlc; + +int main() +{ + const unsigned i = pow2sup<27>::value; + return i != 32; +} Index: tests/array/test_array1d.cc --- tests/array/test_array1d.cc (revision 0) +++ tests/array/test_array1d.cc (revision 0) @@ -0,0 +1,31 @@ +#include <mlc/array/all.hh> +#include <iostream> +using std::cout; +using std::endl; + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; + + array1d< array1d_info< 3 >, int > foo = (ints_1d = 1, 2, 3, end); + cout << endl << "Source:\n\n" << foo << endl; + cout << "After a central symmetry:\n\n" << -foo << endl; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/test_array2d.cc --- tests/array/test_array2d.cc (revision 0) +++ tests/array/test_array2d.cc (revision 0) @@ -0,0 +1,35 @@ +#include <mlc/array/all.hh> +#include <iostream> +using std::cout; +using std::endl; + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; + + array2d< array2d_info< 3, 4, 2>, int > foo = (ints_2d = 1, 2, x(3), 4, lbrk, + 5, 6, 7, 8, + 9, 10, 11, 12, end); + + cout << endl << "Source:\n\n" << foo << endl; + cout << "After a transposition:\n\n" << foo.transpose() << endl; + cout << "After a central symmetry:\n\n" << -foo << endl; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/gen_test_utils/postlude --- tests/array/gen_test_utils/postlude (revision 0) +++ tests/array/gen_test_utils/postlude (revision 0) @@ -0,0 +1,8 @@ + + (void) foo; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/gen_test_utils/errors.cc --- tests/array/gen_test_utils/errors.cc (revision 0) +++ tests/array/gen_test_utils/errors.cc (revision 0) @@ -0,0 +1,290 @@ +#include <iostream> +#include <fstream> +#include <sstream> + +using namespace std; + + +// Warning : +// --------- +// - dimension -> 1-indexed +// - geometry -> 0-indexed +// - position -> 0-indexed + + + +// +// Center +// + + +// If odd -> center +// else -> no center + +int if_center(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + // Checks if one of the sizes is even (-> no automatic center) + for (int i = 0; i < dimension; ++i) + if ((geometry[i] & 1) == 1) // geometry is 0-indexed ! + { + if (position == 0) + ofs << "x(1), "; + else + ofs << "1, "; + return 1; + } + // All sizes are odd + ofs << "1, "; + (void) dimension; (void) geometry; (void) position; + return 1; +} + + +// If odd -> middle +// else -> 1rst position + +int one_center(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + // Checks if one of the sizes is even (-> no automatic center) + for (int i = 0; i < dimension; ++i) + if ((geometry[i] & 1) == 1) // geometry is 0-indexed ! + { + if (position == 0) + ofs << "x(1), "; + else + ofs << "1, "; + return 1; + } + // All sizes are odd + int middle = geometry[0] + 1; + for (int i = dimension - 1; 0 < i; --i) + middle *= (geometry[i] + 1); + middle = middle >> 1; + if (position == middle) + ofs << "x(1), "; + else + ofs << "1, "; + return 1; +} + +int all_centers(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "x(1), "; + (void) position; + for (--dimension; dimension >= 0; --dimension) + if (geometry[dimension] != 0) + return 0; + return 1; +} + + + +// +// Comma +// + + +int no_comma(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == 0) + ofs << "1 "; + else + ofs << "1, "; + (void) dimension; (void) geometry; + return 0; +} + + +// +// No element +// + + +int no_element(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) dimension; (void) geometry; (void) position; + return 0; +} + + + +// +// Linebreak +// + + +int no_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) geometry; (void) position; + return (dimension != 1) ? 0 : 1; +} + +int one_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == geometry[dimension - 1]) + ofs << "lbrk, "; + return (dimension > 1) ? 1 : 0; +} + +int all_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (((position + 1) % (geometry[dimension - 1] + 1)) == 0) + ofs << "lbrk, "; + + if (dimension == 1) + return 0; + for (--(--dimension); dimension >= 0; --dimension) + if (geometry[dimension] != 0) + return 0; + return 1; +} + +int too_much_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "lbrk, "; + (void) dimension; (void) geometry; (void) position; + if (dimension == 1) + return 0; + for (--dimension; dimension >= 0; --dimension) + if (geometry[dimension] != 0) + return 0; + return 1; +} + +int twice_lbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == geometry[dimension - 1]) + ofs << "lbrk, lbrk, "; + return 0; +} + + +// +// Planebreak +// + + +int no_pbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) geometry; (void) position; + return (dimension > 2) ? 0 : 1; +} + +int one_pbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if (position == (geometry[1] + 1) * (geometry[2] + 1) - 1) + ofs << "pbrk, "; + return (dimension > 2) ? 1 : 0; +} + +int all_pbreak(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + if ((position + 1) % ((geometry[1] + 1) * (geometry[2] + 1)) == 0) + ofs << "pbrk, "; + return (dimension < 3) ? 0 : ((geometry[0] == 0) ? 1 : 0); +} + + + +// +// End +// + + +int no_end(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + (void) ofs; (void) dimension; (void) geometry; (void) position; + return 0; +} + +int normal_end(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end);" << endl; + (void) dimension; (void) geometry; (void) position; + return 1; +} + +int end_elt(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, 1);" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} + +int end_lbrk(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, lbrk);" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} + +int end_center(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, x());" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} + +int end_starter(ostream& ofs, + int dimension, + int* geometry, + int position) +{ + ofs << "end, ints = 1);" << endl; + (void) dimension; (void) geometry; (void) position; + return 0; +} Index: tests/array/gen_test_utils/prelude --- tests/array/gen_test_utils/prelude (revision 0) +++ tests/array/gen_test_utils/prelude (revision 0) @@ -0,0 +1,20 @@ +#include <mlc/array/all.hh> + +#include <iostream> + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; Index: tests/array/gen_test_utils/errors.hh --- tests/array/gen_test_utils/errors.hh (revision 0) +++ tests/array/gen_test_utils/errors.hh (revision 0) @@ -0,0 +1,22 @@ +#include <iostream> +#include <fstream> + +int one_center(std::ostream&, int, int*, int); +int if_center(std::ostream&, int, int*, int); +int all_centers(std::ostream&, int, int*, int); +int no_comma(std::ostream&, int, int*, int); +int no_element(std::ostream&, int, int*, int); +int no_lbreak(std::ostream&, int, int*, int); +int one_lbreak(std::ostream&, int, int*, int); +int all_lbreak(std::ostream&, int, int*, int); +int too_much_lbreak(std::ostream&, int, int*, int); +int twice_lbreak(std::ostream&, int, int*, int); +int no_pbreak(std::ostream&, int, int*, int); +int one_pbreak(std::ostream&, int, int*, int); +int all_pbreak(std::ostream&, int, int*, int); +int normal_end(std::ostream&, int, int*, int); +int no_end(std::ostream&, int, int*, int); +int end_elt(std::ostream&, int, int*, int); +int end_lbrk(std::ostream&, int, int*, int); +int end_center(std::ostream&, int, int*, int); +int end_starter(std::ostream&, int, int*, int); Index: tests/array/test_array3d.cc --- tests/array/test_array3d.cc (revision 0) +++ tests/array/test_array3d.cc (revision 0) @@ -0,0 +1,44 @@ +#include <mlc/array/all.hh> +#include <iostream> +using std::cout; +using std::endl; + +#include "check.hh" + +using namespace mlc; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check() +{ + bool fail = false; + + array3d< array3d_info< 2, 2, 3, 1>, int > foo = (ints_3d = 1, x(2), 3, lbrk, + 4, 5, 6, pbrk, + + 7, 8, 9, + 10, 11, 12, end); + + cout << endl << "Source:\n\n" << foo << endl; + + try { + cout << "After a transposition:\n\n" << foo.transpose() << endl; + } + catch (not_implemented_yet) { + cout << endl; + } + + cout << "After a central symmetry:\n\n" << -foo << endl; + + if (1) + OK_OR_FAIL; + + return fail; +} Index: tests/array/Makefile.am --- tests/array/Makefile.am (revision 0) +++ tests/array/Makefile.am (revision 0) @@ -0,0 +1,18 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +include ../check/Makefile.check + +check_PROGRAMS = test_array1d test_array2d test_array3d gen_test + +test_array1d_SOURCES = test_array1d.cc +test_array2d_SOURCES = test_array2d.cc +test_array3d_SOURCES = test_array3d.cc + +gen_test_SOURCES = gen_test.cc +gen_test_LDADD = $(LDADD) gen_test_utils/liberrors.a + +check_LIBRARIES = gen_test_utils/liberrors.a +gen_test_utils_liberrors_a_SOURCES = gen_test_utils/errors.cc gen_test_utils/errors.hh + +EXTRA_DIST = gen_test_utils/prelude gen_test_utils/postlude +CLEANFILES = fail.log success.log a.out gentest_array.cc Index: tests/array/gen_test.cc --- tests/array/gen_test.cc (revision 0) +++ tests/array/gen_test.cc (revision 0) @@ -0,0 +1,346 @@ +#include "config.h" +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> +#include <stdlib.h> +#include <cstdio> +#include <iostream> +#include <fstream> +#include <sstream> +#include "gen_test_utils/errors.hh" +#include "srcdir.hh" +#include "compile.hh" + +using namespace std; + +#define MIN_DIMENSION 1 +#define MAX_DIMENSION 3 + + +static const struct howto +{ + typedef int (*displayer)(ostream&, int, int*, int); + + int ok; + displayer element; + displayer lbreak; + displayer pbreak; + displayer terminate; + const char* verbose; +} methods[][16] = + { + { + // 1D + + { 1, one_center, no_lbreak, no_pbreak, normal_end , + "one_center, no_lbreak, no_pbreak, normal_end" }, + { 1, if_center, no_lbreak, no_pbreak, normal_end , + "if_center, no_lbreak, no_pbreak, normal_end" }, + { 1, all_centers, no_lbreak, no_pbreak, normal_end , + "all_centers!, no_lbreak, no_pbreak, normal_end" }, + { 1, one_center, one_lbreak, no_pbreak, normal_end , + "one_center, one_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, no_lbreak, no_pbreak, no_end , + "one_center, no_lbreak, no_pbreak, no_end!" }, + { 1, one_center, no_lbreak, no_pbreak, end_elt , + "one_center, no_lbreak, no_pbreak, end_elt!" }, + { 1, one_center, no_lbreak, no_pbreak, end_center , + "one_center, no_lbreak, no_pbreak, end_center!" }, + { 1, one_center, no_lbreak, no_pbreak, end_starter , + "one_center, no_lbreak, no_pbreak, end_starter!" }, + { 1, no_comma, no_lbreak, no_pbreak, normal_end , + "no_comma!, no_lbreak, no_pbreak, normal_end" }, + { 1, no_element, no_lbreak, no_pbreak, normal_end , + "no_element!, no_lbreak, no_pbreak, normal_end" }, + { 0, 0, 0, 0, 0, 0 } + }, + { + // 2D + + { 1, one_center, one_lbreak, no_pbreak, normal_end , + "one_center, one_lbreak, no_pbreak, normal_end" }, + { 1, if_center, one_lbreak, no_pbreak, normal_end , + "if_center, one_lbreak, no_pbreak, normal_end" }, + { 1, all_centers, no_lbreak, no_pbreak, normal_end , + "all_centers!, no_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, all_lbreak, no_pbreak, normal_end , + "one_center, all_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, too_much_lbreak, no_pbreak, normal_end , + "one_center, too_much_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, twice_lbreak, no_pbreak, normal_end , + "one_center, twice_lbreak!, no_pbreak, normal_end" }, + { 1, one_center, one_lbreak, no_pbreak, no_end , + "one_center, one_lbreak, no_pbreak, no_end!" }, + { 1, one_center, one_lbreak, no_pbreak, end_elt , + "one_center, one_lbreak, no_pbreak, end_elt!" }, + { 1, one_center, one_lbreak, no_pbreak, end_lbrk , + "one_center, one_lbreak, no_pbreak, end_lbrk!" }, + { 1, one_center, one_lbreak, no_pbreak, end_center , + "one_center, one_lbreak, no_pbreak, end_center!" }, + { 1, one_center, one_lbreak, no_pbreak, end_starter , + "one_center, one_lbreak, no_pbreak, end_starter!" }, + { 1, no_comma, one_lbreak, no_pbreak, normal_end , + "no_comma!, one_lbreak, no_pbreak, normal_end" }, + { 1, no_element, one_lbreak, no_pbreak, normal_end , + "no_element!, one_lbreak, no_pbreak, normal_end" }, + { 0, 0, 0, 0, 0, 0 } + }, + { + // 3D + + { 1, one_center, one_lbreak, one_pbreak, normal_end , + "one_center, one_lbreak, one_pbreak, normal_end" }, + { 1, if_center, one_lbreak, one_pbreak, normal_end , + "if_center, one_lbreak, one_pbreak, normal_end" }, + { 1, one_center, one_lbreak, no_pbreak, normal_end , + "one_center, one_lbreak, no_pbreak!, normal_end" }, + { 1, one_center, one_lbreak, all_pbreak, normal_end , + "one_center, one_lbreak, all_pbreak!, normal_end" }, + { 1, all_centers, no_lbreak, one_pbreak, normal_end , + "all_centers!, no_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, all_lbreak, one_pbreak, normal_end , + "one_center, all_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, too_much_lbreak, one_pbreak, normal_end , + "one_center, too_much_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, twice_lbreak, one_pbreak, normal_end , + "one_center, twice_lbreak!, one_pbreak, normal_end" }, + { 1, one_center, one_lbreak, one_pbreak, no_end , + "one_center, one_lbreak, one_pbreak, no_end!" }, + { 1, one_center, one_lbreak, one_pbreak, end_elt , + "one_center, one_lbreak, one_pbreak, end_elt!" }, + { 1, one_center, one_lbreak, one_pbreak, end_lbrk , + "one_center, one_lbreak, one_pbreak, end_lbrk!" }, + { 1, one_center, one_lbreak, one_pbreak, end_center , + "one_center, one_lbreak, one_pbreak, end_center!" }, + { 1, one_center, one_lbreak, one_pbreak, end_starter , + "one_center, one_lbreak, one_pbreak, end_starter!" }, + { 1, no_comma, one_lbreak, one_pbreak, normal_end , + "no_comma!, one_lbreak, one_pbreak, normal_end" }, + { 1, no_element, one_lbreak, one_pbreak, normal_end , + "no_element!, one_lbreak, one_pbreak, normal_end" }, + { 0, 0, 0, 0, 0, 0 } + } + }; + + + +static void +copyfile (const string & src, ofstream & dest) +{ + ifstream ifs (src.c_str (), ios::in); + string buffer; + + while (!ifs.eof ()) + { + getline (ifs, buffer); + dest << buffer << endl; + } +} + + +static void +write_prelude (ofstream & ofs, const char *filename) +{ + ofs.open (filename, ios::out); + ofs << "// -*-C++-*-" << endl + << "// This temporary file was generated for testing purpose only." + << endl + << "// It's part of Olena, the static generic image processing library." + << endl << endl; + + copyfile (srcdir + "/gen_test_utils/prelude", ofs); +} + +// #include <fstream> + +static bool +write_postlude_and_test (ofstream & ofs, + char *filename, + int dimension, + howto h, + int ok, + ofstream & success_log, + ofstream & fail_log, const stringstream & decl) +{ + copyfile (srcdir + "/gen_test_utils/postlude", ofs); + ofs.close (); + + pid_t pid; + int fd[2]; + pipe (fd); + bool fail = false; + + if ((pid = fork ()) != -1) + if (!pid) + { + dup2 (fd[1], 2); + close (fd[0]); + close (fd[1]); + // FIXME: clean path generation + std::string cmdline = compile_cmd(filename, "", + Isrcdir ("../..") + ' ' + + Isrcdir ("../check") + ' ' + + "-I../../../olena -I../../.. " + + "-L../check -lcheck " + + cxxflags_strict_errors()); + int ret = system (cmdline.c_str ()); + exit (WEXITSTATUS (ret)); + } + else + { + close (fd[1]); + stringstream header; + header << endl << "=== Compiling : [" << dimension << "D]\t" + << h.verbose << endl + << "=== Expected : " << (ok ? "PASS" : "FAIL") << endl << endl; + + stringstream compile_mesg; + char buffer[32]; + { + int r; + while ((r = read (fd[0], buffer, 32)) != 0) + compile_mesg.write (buffer, r); + } + int status; + if (waitpid (pid, &status, 0) == -1) + abort (); + if ((WEXITSTATUS (status) || ok) && !(WEXITSTATUS (status) && ok)) + { + success_log << header.str () << decl.str () + << endl << compile_mesg. + str () << "Exit status = " << WEXITSTATUS (status) << endl << + "===========================================================================" + << endl; + cerr << (ok ? "PASS" : "XFAIL"); + } + else + { + fail_log << header.str () << decl.str () << endl << compile_mesg. + str () << "Exit status = " << WEXITSTATUS (status) << endl << + "===========================================================================" + << endl; + cerr << (ok ? "FAIL" : "XPASS"); + fail = true; + } + close (fd[0]); + cerr << ": [" << dimension << "D]\t" << h.verbose << endl; + } + return fail; +} + + + +static int +fill_array (ostream & ofs, int dimension, int *geometry, howto h) +{ + int *cur_dim = (int *) malloc (dimension * sizeof (int)); + for (int i = dimension - 1; 0 <= i; --i) + cur_dim[i] = geometry[i]; + ++cur_dim[dimension - 1]; + + bool finished = false; + int position = 0; + int ok = h.ok; + while (!finished) + { + for (int d = dimension - 1; 0 <= d; --d) + if (0 <= --cur_dim[d]) + break; + else + { + cur_dim[d] = geometry[d]; + ofs << endl << "\t\t"; + } + + ok &= h.element (ofs, dimension, geometry, position); + ok &= h.lbreak (ofs, dimension, geometry, position); + ok &= h.pbreak (ofs, dimension, geometry, position); + ++position; + finished = true; + for (int i = dimension - 1; 0 <= i; --i) + finished &= (cur_dim[i] == 0); + } + ok &= h.terminate (ofs, dimension, geometry, position); + return ok; +} + + +static bool +write_file (string filename, + int dimension, + int *geometry, + howto h, ofstream & success_log, ofstream & fail_log) +{ + ofstream ofs; + write_prelude (ofs, filename.c_str ()); + + int middle = geometry[0] + 1; + for (int i = dimension - 1; 0 < i; --i) + middle *= (geometry[i] + 1); + middle = middle >> 1; + + stringstream decl; + decl << " array" << dimension << "d< array" << dimension << "d_info< "; + for (int i = 0; i < dimension; ++i) + decl << (geometry[i] + 1) << (i == dimension - 1 ? "" : ", "); + for (int i = 0; i < dimension; ++i) + if (1 == (geometry[i] & 1)) + { + decl << ", 0"; + break; + } + decl << " >, int > foo = (ints_" << dimension << "d = " << endl << "\t\t"; + int ok; + ok = fill_array (decl, dimension, geometry, h); + + ofs << decl.str (); + return write_postlude_and_test (ofs, + const_cast < char *>(filename.c_str ()), + dimension, h, ok, success_log, fail_log, + decl); +} + + +bool +check () +{ + string filename = "gentest_array.cc"; + + ofstream success_log ("success.log", ios::out); + ofstream fail_log ("fail.log", ios::out); + + bool fail = false;; + + for (int dimension = MIN_DIMENSION; dimension <= MAX_DIMENSION; ++dimension) + { + int *current_geometry = (int *) malloc (dimension * sizeof (int)); + for (int i = dimension - 1; i >= 0; --i) + current_geometry[i] = 2; + current_geometry[dimension - 1] = 3; + + bool finished = false; + while (!finished) + { + for (int i = dimension - 1; i >= 0; --i) + if (0 <= --current_geometry[i]) + break; + else + current_geometry[i] = 2; + finished = true; + for (int i = dimension - 1; i >= 0; --i) + if (current_geometry[i] > 0) + finished = false; + + for (int i = 0; methods[dimension - 1][i].element != 0; ++i) + fail |= write_file (filename, dimension, current_geometry, + methods[dimension - 1][i], + success_log, fail_log); + } + free (current_geometry); + } + success_log.close (); + fail_log.close (); + remove (filename.c_str ()); + remove ("./a.out"); + return fail; +}