songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6302 from afabri/P2T2-assert-GF 

CGAL: In testcode do not use CGAL_assertion but assert
This commit is contained in:
Laurent Rineau 2022-02-08 23:44:24 +01:00
parent 9bb38a843b 440a8dfb7b
commit d78a7b9255
26 changed files with 125 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Algebraic_foundations/test/Algebraic_foundations/Chinese_remainder_traits.cpp
View File

@ -103,7 +103,7 @@ void test_CR_for(const NT& f){
// try chinese remainder
do{
// chinese remainder failed if q > 2*max_coeff(f)
CGAL_postcondition_msg(pq < p*(2*max_coeff), " chinese remainder failed ");
assert(pq < p*(2*max_coeff));
prime_index++;
if(prime_index < 1000){

5
BGL/include/CGAL/boost/graph/Seam_mesh.h
View File

@ -19,6 +19,7 @@
#include <CGAL/circulator.h>
#include <CGAL/Unique_hash_map.h>
#include <CGAL/assertions.h>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/unordered_set.hpp>
@ -934,7 +935,7 @@ public:
void build_TM_vertices_vector(std::vector<TM_vertex_descriptor>& tm_vds) const
{
assert(tm_vds.empty());
CGAL_precondition(tm_vds.empty());
// If the input is a list of integers, we need to build a correspondence
// between vertices and integers.
@ -1008,7 +1009,7 @@ public:
TM_halfedge_descriptor add_seams(InputIterator first, InputIterator last)
{
// must have an even number of input vertices
assert(std::distance(first, last) % 2 == 0);
CGAL_precondition(std::distance(first, last) % 2 == 0);
TM_halfedge_descriptor tmhd = boost::graph_traits<TM>::null_halfedge();
InputIterator it = first;

3
BGL/include/CGAL/boost/graph/selection.h
View File

@ -22,6 +22,7 @@
#include <CGAL/boost/graph/alpha_expansion_graphcut.h>
#include <CGAL/squared_distance_3.h>
#include <CGAL/assertions.h>
namespace CGAL {
@ -1112,7 +1113,7 @@ void expand_face_selection_for_removal(const FaceRange& faces_to_be_deleted,
for(halfedge_descriptor f_hd : faces_traversed)
{
assert(target(f_hd, tm) == vd);
CGAL_assertion(target(f_hd, tm) == vd);
put(is_selected, face(f_hd, tm), true);
vertices_queue.insert( target( next(f_hd, tm), tm) );
vertices_queue.insert( source(f_hd, tm) );

13
Combinatorial_map/include/CGAL/Combinatorial_map.h
View File

@ -13,6 +13,7 @@
#define CGAL_COMBINATORIAL_MAP_H 1
#include <CGAL/disable_warnings.h>
#include <CGAL/assertions.h>
#include <CGAL/Combinatorial_map_fwd.h>
@ -2627,7 +2628,7 @@ namespace CGAL {
if ( marks[acells[i]]==INVALID_MARK )
{
marks[acells[i]] = get_new_mark();
assert(is_whole_map_unmarked(marks[acells[i]]));
CGAL_assertion(is_whole_map_unmarked(marks[acells[i]]));
}
}
@ -3636,9 +3637,9 @@ namespace CGAL {
}
}
assert(is_whole_map_unmarked(m1));
assert(is_whole_map_unmarked(markpush));
assert(map2.is_whole_map_unmarked(m2));
CGAL_postcondition(is_whole_map_unmarked(m1));
CGAL_postcondition(is_whole_map_unmarked(markpush));
CGAL_postcondition(map2.is_whole_map_unmarked(m2));
free_mark(m1);
free_mark(markpush);
map2.free_mark(m2);
@ -4660,7 +4661,7 @@ namespace CGAL {
}
// Make copies of the new facet for dimension >=4
assert(!is_free(first, 2));
CGAL_assertion(!is_free(first, 2));
for ( unsigned int dim=4; dim<=dimension; ++dim )
{
if ( !is_free(beta(first, 2), dim) )
@ -4684,7 +4685,7 @@ namespace CGAL {
basic_link_beta_for_involution<2>(beta(it, 3, 2, dim), dd);
}
assert(!is_free(it, 2));
CGAL_assertion(!is_free(it, 2));
this->template basic_link_beta_for_involution<2>(beta(it, 2, dim), d);
if ( prec!=null_handle )

26
Generalized_map/include/CGAL/Generalized_map.h
View File

@ -12,6 +12,8 @@
#ifndef CGAL_GENERALIZED_MAP_H
#define CGAL_GENERALIZED_MAP_H 1
#include <CGAL/assertions.h>
#include <CGAL/Generalized_map_fwd.h>
#include <CGAL/Combinatorial_map/internal/Combinatorial_map_utility.h>
#include <CGAL/Generalized_map/internal/Generalized_map_group_functors.h>
@ -755,14 +757,14 @@ namespace CGAL {
void set_next(Dart_handle dh1, Dart_handle dh2)
{
assert(!this->template is_free<0>(dh1));
CGAL_assertion(!this->template is_free<0>(dh1));
this->template link_alpha<1>(this->template alpha<0>(dh1), dh2); }
template<unsigned int dim>
void set_opposite(Dart_handle dh1, Dart_handle dh2)
{
assert(!this->template is_free<0>(dh1));
assert(!this->template is_free<0>(dh2));
CGAL_assertion(!this->template is_free<0>(dh1));
CGAL_assertion(!this->template is_free<0>(dh2));
this->template link_alpha<dim>(this->template alpha<0>(dh1), dh2);
this->template link_alpha<dim>(dh1, this->template alpha<0>(dh2));
}
@ -780,7 +782,7 @@ namespace CGAL {
size_type number_of_halfedges() const
{
assert(is_without_boundary(0));
CGAL_assertion(is_without_boundary(0));
return number_of_darts()/2;
}
@ -1752,7 +1754,7 @@ namespace CGAL {
if ( marks[acells[i]]==INVALID_MARK )
{
marks[acells[i]] = get_new_mark();
assert(is_whole_map_unmarked(marks[acells[i]]));
CGAL_assertion(is_whole_map_unmarked(marks[acells[i]]));
}
}
@ -2632,9 +2634,9 @@ namespace CGAL {
}
}
assert(is_whole_map_unmarked(m1));
assert(is_whole_map_unmarked(markpush));
assert(map2.is_whole_map_unmarked(m2));
CGAL_postcondition(is_whole_map_unmarked(m1));
CGAL_postcondition(is_whole_map_unmarked(markpush));
CGAL_postcondition(map2.is_whole_map_unmarked(m2));
free_mark(m1);
free_mark(markpush);
map2.free_mark(m2);
@ -2771,11 +2773,11 @@ namespace CGAL {
if (aorientationmark==INVALID_MARK)
{
assert(is_whole_map_marked(orientationmark));
CGAL_assertion(is_whole_map_marked(orientationmark));
free_mark(orientationmark);
}
assert(is_whole_map_marked(ccmark));
CGAL_assertion(is_whole_map_marked(ccmark));
free_mark(ccmark);
}
@ -2817,11 +2819,11 @@ namespace CGAL {
if (aorientationmark==INVALID_MARK)
{
assert(is_whole_map_unmarked(orientationmark));
CGAL_assertion(is_whole_map_unmarked(orientationmark));
free_mark(orientationmark);
}
assert(is_whole_map_unmarked(ccmark));
CGAL_postcondition(is_whole_map_unmarked(ccmark));
free_mark(ccmark);
return orientable;

3
GraphicsView/include/CGAL/Buffer_for_vao.h
View File

@ -22,6 +22,7 @@
#include <CGAL/Constrained_triangulation_plus_2.h>
#include <CGAL/Cartesian_converter.h>
#include <CGAL/IO/Color.h>
#include <CGAL/assertions.h>
#include <vector>
#include <cstdlib>
@ -58,7 +59,7 @@ namespace internal
++nb;
}
assert(nb>0);
CGAL_assertion(nb>0);
return (typename Kernel_traits<Vector>::Kernel::Construct_scaled_vector_3()
(normal, 1.0/nb));
}

37
GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
View File

@ -52,6 +52,7 @@
#include <CGAL/Qt/CreateOpenGLContext.h>
#include <CGAL/Qt/constraint.h>
#include <CGAL/Random.h>
#include <CGAL/assertions.h>
namespace CGAL
{
@ -612,7 +613,7 @@ protected:
vao[VAO_MONO_POINTS].bind();
unsigned int bufn = 0;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_MONO_POINTS].data(),
static_cast<int>(arrays[POS_MONO_POINTS].size()*sizeof(float)));
@ -629,7 +630,7 @@ protected:
vao[VAO_COLORED_POINTS].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_COLORED_POINTS].data(),
static_cast<int>(arrays[POS_COLORED_POINTS].size()*sizeof(float)));
@ -638,7 +639,7 @@ protected:
buffers[bufn].release();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[COLOR_POINTS].data(),
static_cast<int>(arrays[COLOR_POINTS].size()*sizeof(float)));
@ -654,7 +655,7 @@ protected:
vao[VAO_MONO_SEGMENTS].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_MONO_SEGMENTS].data(),
static_cast<int>(arrays[POS_MONO_SEGMENTS].size()*sizeof(float)));
@ -671,7 +672,7 @@ protected:
vao[VAO_COLORED_SEGMENTS].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_COLORED_SEGMENTS].data(),
static_cast<int>(arrays[POS_COLORED_SEGMENTS].size()*sizeof(float)));
@ -681,7 +682,7 @@ protected:
buffers[bufn].release();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[COLOR_SEGMENTS].data(),
static_cast<int>(arrays[COLOR_SEGMENTS].size()*sizeof(float)));
@ -699,7 +700,7 @@ protected:
vao[VAO_MONO_RAYS].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_MONO_RAYS].data(),
static_cast<int>(arrays[POS_MONO_RAYS].size()*sizeof(float)));
@ -717,7 +718,7 @@ protected:
vao[VAO_COLORED_RAYS].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_COLORED_RAYS].data(),
static_cast<int>(arrays[POS_COLORED_RAYS].size()*sizeof(float)));
@ -727,7 +728,7 @@ protected:
buffers[bufn].release();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[COLOR_RAYS].data(),
static_cast<int>(arrays[COLOR_RAYS].size()*sizeof(float)));
@ -744,7 +745,7 @@ protected:
vao[VAO_MONO_LINES].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_MONO_LINES].data(),
static_cast<int>(arrays[POS_MONO_LINES].size()*sizeof(float)));
@ -762,7 +763,7 @@ protected:
vao[VAO_COLORED_LINES].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_COLORED_LINES].data(),
static_cast<int>(arrays[POS_COLORED_LINES].size()*sizeof(float)));
@ -772,7 +773,7 @@ protected:
buffers[bufn].release();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[COLOR_LINES].data(),
static_cast<int>(arrays[COLOR_LINES].size()*sizeof(float)));
@ -792,7 +793,7 @@ protected:
// 5.1.1) points of the mono faces
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_MONO_FACES].data(),
static_cast<int>(arrays[POS_MONO_FACES].size()*sizeof(float)));
@ -803,7 +804,7 @@ protected:
// 5.1.2) normals of the mono faces
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
if (m_flatShading)
{
@ -831,7 +832,7 @@ protected:
// 5.2.1) points of the color faces
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_COLORED_FACES].data(),
static_cast<int>(arrays[POS_COLORED_FACES].size()*sizeof(float)));
@ -842,7 +843,7 @@ protected:
// 5.2.2) normals of the color faces
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
if (m_flatShading)
{
@ -863,7 +864,7 @@ protected:
// 5.2.3) colors of the faces
++bufn;
assert(bufn<NB_VBO_BUFFERS);
CGAL_assertion(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[COLOR_FACES].data(),
static_cast<int>(arrays[COLOR_FACES].size()*sizeof(float)));
@ -886,7 +887,7 @@ protected:
vao[VAO_CLIPPING_PLANE].bind();
++bufn;
assert(bufn < NB_VBO_BUFFERS);
CGAL_assertion(bufn < NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_CLIPPING_PLANE].data(),
static_cast<int>(arrays[POS_CLIPPING_PLANE].size() * sizeof(float)));

3
Hyperbolic_triangulation_2/include/CGAL/Hyperbolic_triangulation_2/internal/Hyperbolic_Delaunay_triangulation_traits_2_functions.h
View File

@ -17,6 +17,7 @@
#include <CGAL/Origin.h>
#include <CGAL/enum.h>
#include <CGAL/assertions.h>
namespace CGAL {
@ -123,7 +124,7 @@ public:
Circle_2 circle = _gt.construct_circle_2_object()(center, sq_radius);
// uncomment!!!
//assert(circle.has_on_boundary(p) && circle.has_on_boundary(q));
// CGAL_assertion(circle.has_on_boundary(p) && circle.has_on_boundary(q));
if(_gt.orientation_2_object()(p, q, center) == LEFT_TURN)
return Circular_arc_2(circle, p, q);

3
Linear_cell_complex/include/CGAL/Linear_cell_complex_base.h
View File

@ -17,6 +17,7 @@
#include <CGAL/Combinatorial_map/internal/Combinatorial_map_internal_functors.h>
#include <CGAL/Linear_cell_complex_operations.h>
#include <CGAL/Origin.h>
#include <CGAL/assertions.h>
#include<map>
@ -513,7 +514,7 @@ namespace CGAL {
{
for (++it2; it2!=it1end; )
{
assert(*it1!=*it2);
CGAL_assertion(*it1!=*it2);
if (!this->template is_opposite_exist<3>(*it2) &&
are_facets_opposite_and_same_geometry
(*it1, this->previous(*it2)))

5
Linear_cell_complex/include/CGAL/Linear_cell_complex_constructors.h
View File

@ -14,6 +14,7 @@
#include <CGAL/IO/OFF.h>
#include <CGAL/Linear_cell_complex_incremental_builder.h>
#include <CGAL/assertions.h>
#include <algorithm>
#include <iostream>
@ -341,7 +342,7 @@ namespace CGAL {
do
{
++n;
assert(alcc.is_next_exist(cur));
CGAL_assertion(alcc.is_next_exist(cur));
cur=alcc.next(cur);
}
while(cur!=itall);
@ -356,7 +357,7 @@ namespace CGAL {
writer.write_facet_vertex_index(index[VCI(alcc.vertex_attribute(cur))]);
alcc.mark(cur, m);
alcc.mark(alcc.other_orientation(cur), m); // for GMap only, for CMap
assert(alcc.is_next_exist(cur)); // marks the same dart twice
CGAL_assertion(alcc.is_next_exist(cur)); // marks the same dart twice
cur=alcc.next(cur);
}
while(cur!=itall);

7
Linear_cell_complex/include/CGAL/Linear_cell_complex_incremental_builder.h
View File

@ -17,6 +17,7 @@
#include <unordered_map>
#include <initializer_list>
#include <CGAL/Linear_cell_complex_base.h>
#include <CGAL/assertions.h>
namespace CGAL {
///////////////////////////////////////////////////////////////////////////////
@ -70,7 +71,7 @@ namespace CGAL {
typename LCC::Dart_handle prev_dart)
{
// here we need to create a last dart and 0-link it
assert(prev_dart!=lcc.null_handle);
CGAL_assertion(prev_dart!=lcc.null_handle);
lcc.template link_alpha<0>(prev_dart, lcc.create_dart(vh));
}
};
@ -353,8 +354,8 @@ public:
DH s2=d2;
do
{
assert(lcc.is_next_exist(d1) && lcc.is_previous_exist(d2));
assert(lcc.other_extremity(d2)!=lcc.null_handle);
CGAL_assertion(lcc.is_next_exist(d1) && lcc.is_previous_exist(d2));
CGAL_assertion(lcc.other_extremity(d2)!=lcc.null_handle);
if (lcc.vertex_attribute(d1)!=lcc.vertex_attribute(d2))
{ return false; }

5
Linear_cell_complex/include/CGAL/Linear_cell_complex_operations.h
View File

@ -15,6 +15,7 @@
#include <CGAL/Cell_iterators.h>
#include <CGAL/Cell_const_iterators.h>
#include <CGAL/Origin.h>
#include <CGAL/assertions.h>
namespace CGAL {
@ -82,7 +83,7 @@ namespace CGAL {
}
while(adart!=start);
assert(nb>0);
CGAL_assertion(nb>0);
return (typename LCC::Traits::Construct_scaled_vector()(normal, 1.0/nb));
// return normal / std::sqrt(normal * normal);
}
@ -201,7 +202,7 @@ namespace CGAL {
}
while(adart!=start);
assert(nb>1);
CGAL_assertion(nb>1);
return typename LCC::Traits::Construct_translated_point()
(CGAL::ORIGIN, typename LCC::Traits::Construct_scaled_vector()
(vec, 1.0/nb));

3
Linear_cell_complex/include/CGAL/boost/graph/graph_traits_Linear_cell_complex_for_combinatorial_map.h
View File

@ -29,6 +29,7 @@
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/iterator.h>
#include <CGAL/assertions.h>
#define CGAL_LCC_TEMPLATE_ARGS template<unsigned int d_, unsigned int ambient_dim, \
class Traits_, \
@ -66,7 +67,7 @@ struct EdgeHandle : Dart_handle
Dart_handle second_halfedge() const
{
assert(*this!=nullptr);
CGAL_assertion(*this!=nullptr);
return (*this)->get_f(2);
}

2
Modifier/test/Modifier/test_modifier.cpp
View File

@ -37,7 +37,7 @@ public:
void delegate( Modifier_base<int>& modifier) {
modifier(i);
// check validity
CGAL_postcondition( i > 0);
assert( i > 0);
}
int get_i() const { return i;} // read access
};

4
Nef_3/include/CGAL/draw_nef_3.h
View File

@ -22,6 +22,8 @@
#include <CGAL/Nef_3/SNC_iteration.h>
#include <CGAL/circulator.h>
#include <CGAL/Random.h>
#include <CGAL/assertions.h>
#include <unordered_map>
namespace CGAL {
@ -209,7 +211,7 @@ protected:
++nb;
}
assert(nb > 0);
CGAL_assertion(nb > 0);
return (typename Local_kernel::Construct_scaled_vector_3()(normal, 1.0 / nb));
}

3
Point_set_3/include/CGAL/Point_set_3.h
View File

@ -24,6 +24,7 @@
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/demangle.h>
#include <CGAL/assertions.h>
#include <algorithm>
#include <iterator>
@ -475,7 +476,7 @@ public:
iterator insert (const Point& p, const Vector& n)
{
iterator out = insert (p);
assert (has_normal_map());
CGAL_assertion(has_normal_map());
m_normals[size()-1] = n;
return out;
}

5
Polygon_mesh_processing/include/CGAL/Polyhedral_envelope.h
View File

@ -69,6 +69,7 @@
#include <CGAL/AABB_primitive.h>
#include <CGAL/Dynamic_property_map.h>
#include <CGAL/assertions.h>
#ifdef CGAL_ENVELOPE_DEBUG
// This is for computing the surface mesh of a prism
@ -1753,7 +1754,7 @@ private:
inter = Implicit_Seg_Facet_interpoint_Out_Prism_return_local_id_with_face_order_jump_over(ip, filtered_intersection, intersect_face, coverlist, jump1, check_id);
assert(inter != 2);// the point must exist because it is a seg-halfplane intersection
CGAL_assertion(inter != 2);// the point must exist because it is a seg-halfplane intersection
if (inter == 1) {
return true;
@ -2084,7 +2085,7 @@ private:
std::cout << p.ep << " | " << p.eq << " | " << p.er << std::endl;
ePoint_3 pv(ver[faces[i][0]].x(), ver[faces[i][0]].y(),ver[faces[i][0]].z());
Orientation ori = orientation(p.ep, p.eq, p.er, pv);
assert(ori == NEGATIVE);
CGAL_assertion(ori == NEGATIVE);
}
#endif

2
Polyhedron/test/Polyhedron/test_polyhedron.cpp
View File

@ -221,7 +221,7 @@ typename Poly::Halfedge_handle make_cube_3( Poly& P) {
Halfedge_handle e = P.split_edge( f);
e->vertex()->point() = Point( 1, 1, 1); // Fig. (e)
P.split_facet( e, f->next()->next()); // Fig. (f)
CGAL_postcondition( P.is_valid());
assert( P.is_valid());
return h;
}

3
Polynomial/test/Polynomial/include/CGAL/gen_sparse_polynomial.h
View File

@ -5,6 +5,7 @@
#include <CGAL/Polynomial_traits_d.h>
#include <CGAL/Random.h>
#include <cmath>
#include <cassert>
namespace CGAL {
@ -36,7 +37,7 @@ generate_sparse_random_polynomial(CGAL::Random random, int max_degree = 6){
Monom_rep monom_rep;
monom_rep.push_back(Monom(exps,c));
result += construct(monom_rep.begin(), monom_rep.end());
CGAL_postcondition(result.degree() >= 0);
assert(result.degree() >= 0);
}
// std::cout << result << std::endl;
return result;

11
STL_Extension/include/CGAL/Compact_container.h
View File

@ -32,6 +32,7 @@
#include <CGAL/CC_safe_handle.h>
#include <CGAL/Time_stamper.h>
#include <CGAL/Has_member.h>
#include <CGAL/assertions.h>
#include <boost/mpl/if.hpp>
@ -480,7 +481,7 @@ public:
// We use the block structure to provide an efficient version :
// we check if the address is in the range of each block.
assert(cit != end());
CGAL_assertion(cit != end());
const_pointer c = &*cit;
size_type res=0;
@ -1050,7 +1051,7 @@ namespace internal {
bool operator<(const CC_iterator& other) const
{
#ifdef CGAL_COMPACT_CONTAINER_DEBUG_TIME_STAMP
assert( is_time_stamp_valid() );
CGAL_assertion( is_time_stamp_valid() );
#endif
return Time_stamper::less(m_ptr, other.m_ptr);
}
@ -1058,7 +1059,7 @@ namespace internal {
bool operator>(const CC_iterator& other) const
{
#ifdef CGAL_COMPACT_CONTAINER_DEBUG_TIME_STAMP
assert( is_time_stamp_valid() );
CGAL_assertion( is_time_stamp_valid() );
#endif
return Time_stamper::less(other.m_ptr, m_ptr);
}
@ -1066,7 +1067,7 @@ namespace internal {
bool operator<=(const CC_iterator& other) const
{
#ifdef CGAL_COMPACT_CONTAINER_DEBUG_TIME_STAMP
assert( is_time_stamp_valid() );
CGAL_assertion( is_time_stamp_valid() );
#endif
return Time_stamper::less(m_ptr, other.m_ptr)
|| (*this == other);
@ -1075,7 +1076,7 @@ namespace internal {
bool operator>=(const CC_iterator& other) const
{
#ifdef CGAL_COMPACT_CONTAINER_DEBUG_TIME_STAMP
assert( is_time_stamp_valid() );
CGAL_assertion( is_time_stamp_valid() );
#endif
return Time_stamper::less(other.m_ptr, m_ptr)
|| (*this == other);

3
STL_Extension/include/CGAL/Concurrent_compact_container.h
View File

@ -27,6 +27,7 @@
#include <CGAL/Compact_container.h>
#include <CGAL/assertions.h>
#include <CGAL/memory.h>
#include <CGAL/iterator.h>
#include <CGAL/CC_safe_handle.h>
@ -481,7 +482,7 @@ public:
// We use the block structure to provide an efficient version :
// we check if the address is in the range of each block.
assert(cit != end());
CGAL_assertion(cit != end());
const_pointer c = &*cit;
size_type res=0;

56
STL_Extension/include/CGAL/STL_Extension/internal/boost/relaxed_heap.hpp
View File

@ -22,6 +22,8 @@
#define BOOST_RELAXED_HEAP_HEADER
#include <CGAL/assertions.h>
#include <functional>
#include <boost/property_map/property_map.hpp>
#include <boost/optional.hpp>
@ -192,7 +194,7 @@ public:
void remove(const value_type& x)
{
group* a = &index_to_group[get(id, x) / log_n];
assert(groups[get(id, x)]);
CGAL_assertion(groups[get(id, x)]);
a->value = x;
a->kind = smallest_key;
promote(a);
@ -203,14 +205,14 @@ public:
value_type& top()
{
find_smallest();
assert(smallest_value->value != boost::none);
CGAL_assertion(smallest_value->value != boost::none);
return *smallest_value->value;
}
const value_type& top() const
{
find_smallest();
assert(smallest_value->value != boost::none);
CGAL_assertion(smallest_value->value != boost::none);
return *smallest_value->value;
}
@ -236,7 +238,7 @@ public:
rank_type r = x->rank;
group* p = x->parent;
{
assert(x->value != boost::none);
CGAL_assertion(x->value != boost::none);
// Find x's group
size_type start = get(id, *x->value) - get(id, *x->value) % log_n;
@ -276,7 +278,7 @@ public:
y->parent = p;
p->children[r] = y;
assert(r == y->rank);
CGAL_assertion(r == y->rank);
if (A[y->rank] == x)
A[y->rank] = do_compare(y, p) ? y : 0;
}
@ -368,7 +370,7 @@ public:
}
else
{
assert(p->parent == p);
CGAL_assertion(p->parent == p);
}
}
if (!in_progress)
@ -481,10 +483,10 @@ private:
void promote(group* a)
{
assert(a != 0);
CGAL_assertion(a != 0);
rank_type r = a->rank;
group* p = a->parent;
assert(p != 0);
CGAL_assertion(p != 0);
if (do_compare(a, p))
{
// s is the rank + 1 sibling
@ -500,7 +502,7 @@ private:
}
else
{
assert(s != 0);
CGAL_assertion(s != 0);
if (A[r + 1] == s)
active_sibling_transform(a, s);
else
@ -511,7 +513,7 @@ private:
group* combine(group* a1, group* a2)
{
assert(a1->rank == a2->rank);
CGAL_assertion(a1->rank == a2->rank);
if (do_compare(a2, a1))
do_swap(a1, a2);
a1->children[a1->rank++] = a2;
@ -528,7 +530,7 @@ private:
rank_type s = q->rank - 2;
group* x = q->children[s];
group* xp = qp->children[s];
assert(s == x->rank);
CGAL_assertion(s == x->rank);
// If x is active, swap x and xp
if (A[s] == x)
@ -549,35 +551,35 @@ private:
// p is a's parent
group* p = a->parent;
assert(p != 0);
CGAL_assertion(p != 0);
// g is p's parent (a's grandparent)
group* g = p->parent;
assert(g != 0);
CGAL_assertion(g != 0);
// a' <- A(r)
assert(A[r] != 0);
CGAL_assertion(A[r] != 0);
group* ap = A[r];
assert(ap != 0);
CGAL_assertion(ap != 0);
// A(r) <- nil
A[r] = 0;
// let a' have parent p'
group* pp = ap->parent;
assert(pp != 0);
CGAL_assertion(pp != 0);
// let a' have grandparent g'
group* gp = pp->parent;
assert(gp != 0);
CGAL_assertion(gp != 0);
// Remove a and a' from their parents
assert(ap
CGAL_assertion(ap
== pp->children[pp->rank - 1]); // Guaranteed because ap is active
--pp->rank;
// Guaranteed by caller
assert(a == p->children[p->rank - 1]);
CGAL_assertion(a == p->children[p->rank - 1]);
--p->rank;
// Note: a, ap, p, pp all have rank r
@ -590,7 +592,7 @@ private:
// Assuming k(p) <= k(p')
// make p' the rank r child of p
assert(r == p->rank);
CGAL_assertion(r == p->rank);
p->children[p->rank++] = pp;
pp->parent = p;
@ -598,7 +600,7 @@ private:
group* c = combine(a, ap);
// make c the rank r+1 child of g'
assert(gp->rank > r + 1);
CGAL_assertion(gp->rank > r + 1);
gp->children[r + 1] = c;
c->parent = gp;
@ -622,10 +624,10 @@ private:
group* g = p->parent;
// remove a, s from their parents
assert(s->parent == p);
assert(p->children[p->rank - 1] == s);
CGAL_assertion(s->parent == p);
CGAL_assertion(p->children[p->rank - 1] == s);
--p->rank;
assert(p->children[p->rank - 1] == a);
CGAL_assertion(p->children[p->rank - 1] == a);
--p->rank;
rank_type r = a->rank;
@ -634,7 +636,7 @@ private:
group* c = combine(a, s);
// make c the rank r+2 child of g
assert(g->children[r + 2] == p);
CGAL_assertion(g->children[r + 2] == p);
g->children[r + 2] = c;
c->parent = g;
if (A[r + 2] == p)
@ -650,7 +652,7 @@ private:
#endif
rank_type r = a->rank;
group* c = s->children[s->rank - 1];
assert(c->rank == r);
CGAL_assertion(c->rank == r);
if (A[r] == c)
{
#if defined(BOOST_RELAXED_HEAP_DEBUG) && BOOST_RELAXED_HEAP_DEBUG > 1
@ -667,7 +669,7 @@ private:
p->children[r] = s;
// combine a, c and let the result by the rank r+1 child of p
assert(p->rank > r + 1);
CGAL_assertion(p->rank > r + 1);
group* x = combine(a, c);
x->parent = p;
p->children[r + 1] = x;

8
Surface_mesh_parameterization/include/CGAL/Surface_mesh_parameterization/Square_border_parameterizer_3.h
View File

@ -15,6 +15,7 @@
#include <CGAL/license/Surface_mesh_parameterization.h>
#include <CGAL/disable_warnings.h>
#include <CGAL/assertions.h>
#include <CGAL/Surface_mesh_parameterization/internal/kernel_traits.h>
#include <CGAL/Surface_mesh_parameterization/Error_code.h>
@ -23,6 +24,7 @@
#include <CGAL/boost/graph/iterator.h>
#include <cfloat>
#include <climits>
#include <vector>
@ -200,7 +202,7 @@ private:
VertexParameterizedMap vpmap,
Offset_map& offset)
{
assert(offset.empty());
CGAL_assertion(offset.empty());
put(vpmap, v0, true);
put(vpmap, v1, true);
@ -234,7 +236,7 @@ private:
if(get(vpmap, vt)) {
// If both extremeties of a segment are corners, offsets are already correct
if(!get(vpmap, vs)) {
assert(len != 0.0);
CGAL_assertion(len != 0.0);
double ld = 1.0 / len;
for(std::size_t i=index_of_previous_corner+1; i<=current_index; ++i) {
// ld * offset[i] is in [0;1[
@ -333,7 +335,7 @@ public:
for(halfedge_descriptor hd : halfedges_around_face(start_hd, mesh)) {
vertex_descriptor vd = source(hd, mesh);
Point_2 uv;
assert(counter < offset.size());
CGAL_assertion(counter < offset.size());
if(corners_encountered == 0)
uv = Point_2(offset[counter++], 0.0);

4
Surface_mesh_topology/include/CGAL/Face_graph_wrapper.h
View File

@ -13,6 +13,7 @@
#define CGAL_FACE_GRAPH_WRAPPER_H 1
#include <CGAL/license/Surface_mesh_topology.h>
#include <CGAL/assertions.h>
#include <CGAL/Surface_mesh_topology/internal/Functors_for_face_graph_wrapper.h>
#include <CGAL/Surface_mesh_topology/internal/Iterators_for_face_graph_wrapper.h>
@ -23,6 +24,7 @@
#include <CGAL/Generalized_map_fwd.h>
#include <CGAL/Linear_cell_complex_fwd.h>
#include <CGAL/Polygonal_schema_fwd.h>
#include <bitset>
namespace CGAL
@ -614,7 +616,7 @@ public:
if (marks[acells[i]]==INVALID_MARK )
{
marks[acells[i]]=get_new_mark();
assert(is_whole_map_unmarked(marks[acells[i]]));
CGAL_assertion(is_whole_map_unmarked(marks[acells[i]]));
}
}

3
Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Path_generators.h
View File

@ -13,6 +13,7 @@
#define CGAL_PATH_GENERATORS_H 1
#include <CGAL/license/Surface_mesh_topology.h>
#include <CGAL/assertions.h>
#include <CGAL/Random.h>
#include <unordered_set>
@ -174,7 +175,7 @@ generate_random_connected_set_of_faces(const LCC& lcc, std::size_t nb,
{ return NULL; }
}
assert (border_faces.size()!=0);
CGAL_assertion(border_faces.size()!=0);
typename LCC::Dart_const_handle dhres=border_faces[0];
while(lcc.template is_free<2>(dhres) ||
lcc.is_marked(lcc.template beta<2>(dhres), amark))

3
Surface_mesh_topology/include/CGAL/draw_face_graph_with_paths.h
View File

@ -18,6 +18,7 @@
#include <initializer_list>
#include <CGAL/draw_linear_cell_complex.h>
#include <CGAL/Path_on_surface.h>
#include <CGAL/assertions.h>
#ifdef CGAL_USE_BASIC_VIEWER
@ -52,7 +53,7 @@ struct LCC_geom_utils<CGAL::Face_graph_wrapper<Mesh>, Local_kernel, 3>
}
while(adart!=dh);
assert(nb>0);
CGAL_assertion(nb>0);
return typename Get_traits<Mesh>::Kernel::Construct_scaled_vector_3()
(normal, 1.0/nb);
}