OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/tags/gnu-dev/fsf-gcc-snapshot-1-mar-12/or1k-gcc/libstdc++-v3/testsuite/20_util/shared_ptr
    from Rev 742 to Rev 783
    ↔ Reverse comparison
  •

Rev 742 → Rev 783

/dest/dest.cc
0,0 → 1,134
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A() { ++ctor_count; }
~A() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long A::ctor_count = 0;
long A::dtor_count = 0;
 
struct B : A
{
B() { ++ctor_count; }
~B() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long B::ctor_count = 0;
long B::dtor_count = 0;
 
struct D
{
void operator()(const B* p) { delete p; ++delete_count; }
static long delete_count;
};
long D::delete_count = 0;
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
B::ctor_count = 0;
B::dtor_count = 0;
D::delete_count = 0;
}
};
 
 
// 20.6.6.2.2 shared_ptr destructor [util.smartptr.shared.dest]
 
// empty shared_ptr
int
test01()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
{
std::shared_ptr<A> a;
}
VERIFY( A::ctor_count == 0 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 0 );
VERIFY( B::dtor_count == 0 );
VERIFY( D::delete_count == 0 );
 
return 0;
}
 
// shared ownership
int
test02()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
{
a = std::shared_ptr<A>(new B, D());
}
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
VERIFY( D::delete_count == 0 );
 
return 0;
}
 
// exclusive ownership
int
test03()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
{
std::shared_ptr<A> a1(new B);
std::shared_ptr<A> a2(new B, D());
}
VERIFY( A::ctor_count == 2 );
VERIFY( A::dtor_count == 2 );
VERIFY( B::ctor_count == 2 );
VERIFY( B::dtor_count == 2 );
VERIFY( D::delete_count == 1 );
 
return 0;
}
 
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/modifiers/reset_neg.cc
0,0 → 1,47
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
 
// reset
int
test01()
{
bool test __attribute__((unused)) = true;
 
const std::shared_ptr<A> p1(new A);
p1.reset(); // { dg-error "discards qualifiers" }
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/modifiers/reset_alloc.cc
0,0 → 1,63
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
 
using __gnu_test::tracker_allocator_counter;
using __gnu_test::tracker_allocator;
 
struct A { };
struct B : A { };
struct D
{
void operator()(B* p) { delete p; ++delete_count; }
static long delete_count;
};
long D::delete_count = 0;
 
// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
 
// Reset with allocator
int
test01()
{
bool test __attribute__((unused)) = true;
tracker_allocator_counter::reset();
 
{
std::shared_ptr<A> p1;
p1.reset(new B, D(), tracker_allocator<B>());
VERIFY( tracker_allocator_counter::get_allocation_count() > 0 );
}
VERIFY( D::delete_count == 1 );
VERIFY( tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count() );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/modifiers/reset.cc
0,0 → 1,89
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
struct B : A { };
struct D
{
void operator()(B* p) { delete p; ++delete_count; }
static long delete_count;
};
long D::delete_count = 0;
 
// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
 
// reset
int
test01()
{
bool test __attribute__((unused)) = true;
 
A * const a = new A;
std::shared_ptr<A> p1(a);
std::shared_ptr<A> p2(p1);
p1.reset();
VERIFY( p1.get() == 0 );
VERIFY( p2.get() == a );
 
return 0;
}
 
int
test02()
{
bool test __attribute__((unused)) = true;
 
A * const a = new A;
B * const b = new B;
std::shared_ptr<A> p1(a);
std::shared_ptr<A> p2(p1);
p1.reset(b);
VERIFY( p1.get() == b );
VERIFY( p2.get() == a );
 
return 0;
}
 
int
test03()
{
bool test __attribute__((unused)) = true;
 
{
std::shared_ptr<A> p1;
p1.reset(new B, D());
}
VERIFY( D::delete_count == 1 );
 
return 0;
}
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/modifiers/24805.cc
0,0 → 1,30
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
 
// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
 
// swap
 
// libstdc++/24805
using std::swap;
/modifiers/swap_neg.cc
0,0 → 1,48
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
 
// swap
int
test01()
{
bool test __attribute__((unused)) = true;
 
const std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2(new A);
p1.swap(p2); // { dg-error "discards qualifiers" }
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/modifiers/swap.cc
0,0 → 1,51
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
 
// swap
int
test01()
{
bool test __attribute__((unused)) = true;
 
A * const a1 = new A;
A * const a2 = new A;
std::shared_ptr<A> p1(a1);
std::shared_ptr<A> p2(a2);
p1.swap(p2);
VERIFY( p1.get() == a2 );
VERIFY( p2.get() == a1 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/unique_ptr.cc
0,0 → 1,49
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::unique_ptr<A> up(new A);
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/weak_ptr_expired.cc
0,0 → 1,58
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009, 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from expired weak_ptr
int
test01()
{
bool test = false;
 
std::shared_ptr<A> a1(new A);
std::weak_ptr<A> wa(a1);
a1.reset();
VERIFY( wa.expired() );
try
{
std::shared_ptr<A> a2(wa);
}
catch (const std::bad_weak_ptr&)
{
// Expected.
test = true;
}
VERIFY( test );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/alloc_min.cc
0,0 → 1,35
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.2.2 Class template shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_allocator.h>
 
struct X { };
 
// 20.7.2.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// test shared_ptr with minimal allocator
 
__gnu_test::SimpleAllocator<X> alloc;
auto deleter = [](X* p) { delete p; };
std::shared_ptr<X> p(new X, deleter, alloc);
 
/cons/auto_ptr.cc
0,0 → 1,49
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from auto_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::auto_ptr<A> a(new A);
std::shared_ptr<A> a2(std::move(a));
VERIFY( a.get() == 0 );
VERIFY( a2.get() != 0 );
VERIFY( a2.use_count() == 1 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/unique_ptr_deleter.cc
0,0 → 1,59
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
struct D {
void operator()(A* p) const { delete p; ++count; }
static int count;
};
 
int D::count = 0;
 
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::unique_ptr<A, D> up(new A, D());
{
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
}
VERIFY( D::count == 1 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/nullptr.cc
0,0 → 1,93
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2010 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.9.11.2 Class template shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <cstddef>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
 
// 20.9.11.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from nullptr
 
struct deleter
{
int count;
deleter() : count(0) { }
void operator()(std::nullptr_t) { ++count; }
void operator()(int*) const { throw "wrong type passed to deleter"; }
};
 
void
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<int> p = nullptr;
VERIFY( p.get() == nullptr );
VERIFY( p.use_count() == 0 );
 
}
 
void
test02()
{
bool test __attribute__((unused)) = true;
 
deleter d;
std::shared_ptr<int> p(nullptr, std::ref(d));
VERIFY( p.get() == nullptr );
VERIFY( p.use_count() == 1 );
 
p = nullptr;
VERIFY( p.use_count() == 0 );
VERIFY( d.count == 1 );
}
 
 
void
test03()
{
bool test __attribute__((unused)) = true;
 
deleter d;
__gnu_test::tracker_allocator<int> a;
std::shared_ptr<int> p(nullptr, std::ref(d), a);
VERIFY( p.get() == nullptr );
VERIFY( p.use_count() == 1 );
 
p = nullptr;
VERIFY( p.use_count() == 0 );
VERIFY( d.count == 1 );
 
typedef __gnu_test::tracker_allocator_counter c;
VERIFY( c::get_destruct_count() == c::get_construct_count() );
VERIFY( c::get_deallocation_count() == c::get_allocation_count() );
}
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/cons/move.cc
0,0 → 1,164
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// TR1 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <utility>
#include <testsuite_hooks.h>
 
struct A
{
A() { ++ctor_count; }
virtual ~A() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long A::ctor_count = 0;
long A::dtor_count = 0;
 
struct B : A
{
B() { ++ctor_count; }
virtual ~B() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long B::ctor_count = 0;
long B::dtor_count = 0;
 
struct D
{
void operator()(B* p) const { delete p; ++delete_count; }
static long delete_count;
};
long D::delete_count = 0;
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
B::ctor_count = 0;
B::dtor_count = 0;
D::delete_count = 0;
}
};
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Rvalue construction
int test01()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a1;
std::shared_ptr<A> a2(std::move(a1));
VERIFY( a1.use_count() == 0 );
VERIFY( a2.use_count() == 0 );
VERIFY( A::ctor_count == 0 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 0 );
VERIFY( B::dtor_count == 0 );
 
return 0;
}
 
int
test02()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a1(new A);
std::shared_ptr<A> a2(std::move(a1));
VERIFY( a1.use_count() == 0 );
VERIFY( a2.use_count() == 1 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
 
return 0;
}
 
int
test03()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<B> b(new B);
std::shared_ptr<A> a(std::move(b));
VERIFY( b.use_count() == 0 );
VERIFY( a.use_count() == 1 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
 
return 0;
}
 
int
test04()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<B> b(new B, D());
std::shared_ptr<A> a(std::move(b));
VERIFY( b.use_count() == 0 );
VERIFY( a.use_count() == 1 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
 
a = std::move(std::shared_ptr<A>());
VERIFY( D::delete_count == 1 );
VERIFY( B::dtor_count == 1 );
 
return 0;
}
 
int
test05()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a(std::move(std::shared_ptr<A>(new A)));
VERIFY( a.use_count() == 1 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
 
return 0;
}
 
int
main()
{
test01();
test02();
test03();
test04();
test05();
return 0;
}
/cons/43820_neg.cc
0,0 → 1,40
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2010, 2011, 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.9.11.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
 
// incomplete type
struct X;
 
// get an auto_ptr rvalue
std::auto_ptr<X>&& ap();
 
void test01()
{
X* px = 0;
std::shared_ptr<X> p1(px); // { dg-error "here" }
// { dg-error "incomplete" "" { target *-*-* } 771 }
 
std::shared_ptr<X> p9(ap()); // { dg-error "here" }
// { dg-error "incomplete" "" { target *-*-* } 865 }
 
}
/cons/copy.cc
0,0 → 1,136
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A() { ++ctor_count; }
virtual ~A() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long A::ctor_count = 0;
long A::dtor_count = 0;
 
struct B : A
{
B() { ++ctor_count; }
virtual ~B() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long B::ctor_count = 0;
long B::dtor_count = 0;
 
void deleter(A* p) { delete p; }
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
B::ctor_count = 0;
B::dtor_count = 0;
}
};
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Copy construction
int test01()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a1;
std::shared_ptr<A> a2(a1);
VERIFY( a2.use_count() == 0 );
VERIFY( A::ctor_count == 0 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 0 );
VERIFY( B::dtor_count == 0 );
 
return 0;
}
 
int
test02()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a1(new A);
std::shared_ptr<A> a2(a1);
VERIFY( a2.use_count() == 2 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 0 );
VERIFY( B::dtor_count == 0 );
 
return 0;
}
 
int
test03()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<B> b(new B);
std::shared_ptr<A> a(b);
VERIFY( a.use_count() == 2 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
 
return 0;
}
 
int
test04()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<B> b(new B, &deleter);
std::shared_ptr<A> a(b);
VERIFY( a.use_count() == 2 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
 
return 0;
}
 
int
main()
{
test01();
test02();
test03();
test04();
return 0;
}
/cons/unique_ptr_deleter_ref_1.cc
0,0 → 1,60
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
struct D {
typedef void result_type;
void operator()(A* p) { delete p; ++count; }
int count;
};
 
 
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
D d = D();
std::unique_ptr<A, D&> up(new A, d);
{
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
}
VERIFY( d.count == 1 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/weak_ptr.cc
0,0 → 1,51
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from weak_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
A * const a = new A;
std::shared_ptr<A> a1(a);
std::weak_ptr<A> wa(a1);
std::shared_ptr<A> a2(wa);
VERIFY( a2.get() == a );
VERIFY( a2.use_count() == wa.use_count() );
 
return 0;
}
 
 
int
main()
{
test01();
return 0;
}
/cons/unique_ptr_deleter_ref_2.cc
0,0 → 1,63
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <functional>
#include <testsuite_hooks.h>
 
struct A { };
 
struct D {
typedef void result_type;
void operator()(A* p) { delete p; ++count; }
int count;
};
 
 
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from unique_ptr
// See: http://gcc.gnu.org/ml/libstdc++/2008-09/msg00070.html.
int
test01()
{
bool test __attribute__((unused)) = true;
 
D d;
std::unique_ptr<A, D&> p1(new A, d);
 
std::shared_ptr<A> p2(std::move(p1));
 
typedef std::reference_wrapper<D> D2;
D2* p3 = std::get_deleter<D2>(p2);
 
VERIFY( p3 != 0 );
VERIFY( &p3->get() == &d );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/noexcept_move_construct.cc
0,0 → 1,27
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
 
// 2011-06-14 Paolo Carlini <paolo.carlini@oracle.com>
//
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
//
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
#include <memory>
 
typedef std::shared_ptr<int> sptype;
 
static_assert(std::is_nothrow_move_constructible<sptype>::value, "Error");
/cons/pointer.cc
0,0 → 1,80
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009, 2010 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
struct B : A { };
 
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from pointer
 
int
test01()
{
bool test __attribute__((unused)) = true;
 
A * const a = 0;
std::shared_ptr<A> p(a);
VERIFY( p.get() == 0 );
VERIFY( p.use_count() == 1 );
 
return 0;
}
 
int
test02()
{
bool test __attribute__((unused)) = true;
 
A * const a = new A;
std::shared_ptr<A> p(a);
VERIFY( p.get() == a );
VERIFY( p.use_count() == 1 );
 
return 0;
}
 
 
int
test03()
{
bool test __attribute__((unused)) = true;
 
B * const b = new B;
std::shared_ptr<A> p(b);
VERIFY( p.get() == b );
VERIFY( p.use_count() == 1 );
 
return 0;
}
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/cons/46910.cc
0,0 → 1,46
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2010 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.9.10.2 Class template shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
// 20.9.10.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
struct deleter;
 
class A
{
~A() = default;
friend struct deleter;
};
 
struct deleter
{
void operator()(A* a) const;
};
 
void
test01()
{
std::shared_ptr<A> p(new A, deleter());
}
 
/cons/default.cc
0,0 → 1,46
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Default construction
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
VERIFY( a.get() == 0 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/cons/unique_ptr_neg.cc
0,0 → 1,48
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2008, 2009, 2010 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction from lvalue unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::unique_ptr<A> a;
std::shared_ptr<A> p(a); // { dg-error "cannot bind" }
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
// { dg-prune-output "initializing argument" }
/cons/39405.cc
0,0 → 1,30
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
#include <memory>
 
// libstdc++/39405
template<typename T>
struct foo
{
std::shared_ptr<foo<T> > m_foo;
};
 
std::shared_ptr<foo<int> > t;
/cons/constexpr.cc
0,0 → 1,35
// { dg-do compile }
// { dg-options "-std=gnu++0x -fno-inline -save-temps -g0" }
// { dg-final { scan-assembler-not "_ZNSt10shared_ptrIiEC2Ev" } }
// { dg-final { scan-assembler-not "_ZNSt10shared_ptrIiEC2EDn" } }
 
// Copyright (C) 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
#include <memory>
#include <testsuite_common_types.h>
 
int main()
{
__gnu_test::constexpr_default_constructible test1; //not literal
test1.operator()<std::shared_ptr<int>>();
 
__gnu_test::constexpr_single_value_constructible test2; //not literal
test2.operator()<std::shared_ptr<int>, std::nullptr_t>();
 
return 0;
}
/cons/auto_ptr_neg.cc
0,0 → 1,35
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
 
struct A { };
 
// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.const]
 
// Construction from const auto_ptr
void
test01()
{
const std::auto_ptr<A> a;
std::shared_ptr<A> p(std::move(a)); // { dg-error "no match" }
}
/cons/alias.cc
0,0 → 1,107
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A() : i() { }
virtual ~A() { }
int i;
};
 
struct B : A
{
B() : A(), a() { }
virtual ~B() { }
A a;
};
 
void deletefunc(A* p) { delete p; }
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Aliasing constructors
 
int test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
std::shared_ptr<bool> b1(a, &test);
VERIFY( b1.use_count() == 0 );
VERIFY( a.get() == 0 );
VERIFY( b1.get() == &test );
 
std::shared_ptr<bool> b2(b1);
VERIFY( b2.use_count() == 0 );
VERIFY( b1.get() == b2.get() );
 
return 0;
}
 
int
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a(new A);
std::shared_ptr<int> i1(a, &a->i);
VERIFY( i1.use_count() == 2 );
 
std::shared_ptr<int> i2(i1);
VERIFY( i2.use_count() == 3 );
VERIFY( i2.get() == &a->i );
 
return 0;
}
 
int
test03()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<B> b(new B);
std::shared_ptr<A> a1(b, b.get());
std::shared_ptr<A> a2(b, &b->a);
VERIFY( a2.use_count() == 3 );
VERIFY( a1 == b );
VERIFY( a2 != b );
VERIFY( a1.get() != a2.get() );
 
std::shared_ptr<A> a3(a1);
VERIFY( a3 == b );
 
a3 = a2;
VERIFY( a3.get() == &b->a );
 
return 0;
}
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/cons/alloc.cc
0,0 → 1,103
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
 
using __gnu_test::tracker_allocator_counter;
using __gnu_test::tracker_allocator;
 
struct A { };
void deletefunc(A* p) { delete p; }
struct D
{
void operator()(A* p) { delete p; ++delete_count; }
static long delete_count;
};
long D::delete_count = 0;
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Construction with allocator
int
test01()
{
bool test __attribute__((unused)) = true;
tracker_allocator_counter::reset();
 
std::shared_ptr<A> p1(new A, deletefunc, tracker_allocator<A>());
std::size_t const sz = tracker_allocator_counter::get_allocation_count();
VERIFY( sz > 0 );
{
std::shared_ptr<A> p2(p1);
VERIFY( p2.use_count() == 2 );
VERIFY( tracker_allocator_counter::get_allocation_count() == sz );
VERIFY( tracker_allocator_counter::get_deallocation_count() == 0 );
}
VERIFY( p1.use_count() == 1 );
VERIFY( tracker_allocator_counter::get_allocation_count() == sz );
VERIFY( tracker_allocator_counter::get_deallocation_count() == 0 );
p1.reset();
VERIFY( p1.use_count() == 0 );
VERIFY( tracker_allocator_counter::get_allocation_count() == sz );
VERIFY( tracker_allocator_counter::get_deallocation_count() == sz );
 
return 0;
}
 
// Construction with allocator
int
test02()
{
bool test __attribute__((unused)) = true;
tracker_allocator_counter::reset();
 
std::shared_ptr<A> p1(new A, deletefunc, tracker_allocator<A>());
std::size_t const sz1 = tracker_allocator_counter::get_allocation_count();
VERIFY( sz1 > 0 );
std::shared_ptr<A> p2(new A, D(), tracker_allocator<A>());
std::size_t const sz2 = tracker_allocator_counter::get_allocation_count();
VERIFY( sz2 > sz1 );
VERIFY( tracker_allocator_counter::get_deallocation_count() == 0 );
p1 = p2;
VERIFY( p2.use_count() == 2 );
VERIFY( tracker_allocator_counter::get_allocation_count() == sz2 );
VERIFY( tracker_allocator_counter::get_deallocation_count() == sz1 );
p1.reset();
VERIFY( p2.use_count() == 1 );
VERIFY( tracker_allocator_counter::get_allocation_count() == sz2 );
VERIFY( tracker_allocator_counter::get_deallocation_count() == sz1 );
p2.reset();
VERIFY( tracker_allocator_counter::get_allocation_count() == sz2 );
VERIFY( tracker_allocator_counter::get_deallocation_count() == sz2 );
VERIFY( D::delete_count == 1 );
 
return 0;
}
 
int
main()
{
test01();
test02();
return 0;
}
/hash/1.cc
0,0 → 1,48
// { dg-options "-std=gnu++0x" }
 
// 2010-06-11 Paolo Carlini <paolo.carlini@oracle.com>
 
// Copyright (C) 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
#include <memory>
#include <testsuite_hooks.h>
 
void test01()
{
bool test __attribute__((unused)) = true;
 
struct T { };
 
std::shared_ptr<T> s0(new T);
std::hash<std::shared_ptr<T>> hs0;
std::hash<T*> hp0;
 
VERIFY( hs0(s0) == hp0(s0.get()) );
 
std::__shared_ptr<T> s1(new T);
std::hash<std::__shared_ptr<T>> hs1;
std::hash<T*> hp1;
 
VERIFY( hs1(s1) == hp1(s1.get()) );
}
 
int main()
{
test01();
return 0;
}
/requirements/explicit_instantiation/1.cc
0,0 → 1,31
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_tr1.h>
 
using namespace __gnu_test;
using std::shared_ptr;
template class shared_ptr<int>;
template class shared_ptr<void>;
template class shared_ptr<ClassType>;
template class shared_ptr<IncompleteClass>;
/requirements/explicit_instantiation/2.cc
0,0 → 1,34
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_tr1.h>
 
// Check the _S_single lock policy can be instantiated. For a thread-enabled
// library this checks the templates can be instantiated for non-default
// lock policy, for a single-threaded lib this is redundant but harmless.
using namespace __gnu_test;
using std::__shared_ptr;
using std::_S_single;
template class __shared_ptr<int, _S_single>;
template class __shared_ptr<ClassType, _S_single>;
template class __shared_ptr<IncompleteClass, _S_single>;
/assign/auto_ptr_rvalue.cc
0,0 → 1,61
// { dg-options "-std=gnu++0x -Wno-deprecated" }
// { dg-do compile }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
std::auto_ptr<A> source() { return std::auto_ptr<A>(); }
 
// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from rvalue auto_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
a = source();
 
return 0;
}
 
int
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
std::auto_ptr<A> au;
a = std::move(au);
 
return 0;
}
 
int
main()
{
test01();
test02();
return 0;
}
/assign/shared_ptr.cc
0,0 → 1,96
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A() { ++ctor_count; }
virtual ~A() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long A::ctor_count = 0;
long A::dtor_count = 0;
 
struct B : A
{
B() { ++ctor_count; }
virtual ~B() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long B::ctor_count = 0;
long B::dtor_count = 0;
 
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
B::ctor_count = 0;
B::dtor_count = 0;
}
};
 
 
// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from shared_ptr<Y>
void
test01()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
 
a = std::shared_ptr<A>();
VERIFY( a.get() == 0 );
VERIFY( A::ctor_count == 0 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 0 );
VERIFY( B::dtor_count == 0 );
 
a = std::shared_ptr<A>(new A);
VERIFY( a.get() != 0 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 0 );
VERIFY( B::dtor_count == 0 );
 
a = std::shared_ptr<B>(new B);
VERIFY( a.get() != 0 );
VERIFY( A::ctor_count == 2 );
VERIFY( A::dtor_count == 1 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
}
 
int
main()
{
test01();
return 0;
}
/assign/unique_ptr_lvalue_neg.cc
0,0 → 1,49
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2008, 2009, 2010 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from lvalue unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
std::unique_ptr<A> u;
a = u; // { dg-error "cannot bind" }
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
// { dg-prune-output "initializing argument" }
/assign/auto_ptr.cc
0,0 → 1,85
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A() { ++ctor_count; }
virtual ~A() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long A::ctor_count = 0;
long A::dtor_count = 0;
 
struct B : A
{
B() { ++ctor_count; }
virtual ~B() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long B::ctor_count = 0;
long B::dtor_count = 0;
 
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
B::ctor_count = 0;
B::dtor_count = 0;
}
};
 
 
// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from auto_ptr<Y>
int
test01()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a(new A);
std::auto_ptr<B> b(new B);
a = std::move(b);
VERIFY( a.get() != 0 );
VERIFY( b.get() == 0 );
VERIFY( A::ctor_count == 2 );
VERIFY( A::dtor_count == 1 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/assign/dr541.cc
0,0 → 1,30
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
 
// DR 541. shared_ptr template assignment and void
void test01()
{
std::shared_ptr<void> p;
p.operator=<void>(p);
}
/assign/shared_ptr_neg.cc
0,0 → 1,52
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
struct B { };
 
// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from incompatible shared_ptr<Y>
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
std::shared_ptr<B> b;
a = b; // { dg-error "here" }
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
// { dg-error "In instantiation" "" { target *-*-* } 0 }
// { dg-error "cannot convert" "" { target *-*-* } 0 }
// { dg-error "required from" "" { target *-*-* } 0 }
/assign/assign.cc
0,0 → 1,72
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A() { ++ctor_count; }
virtual ~A() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long A::ctor_count = 0;
long A::dtor_count = 0;
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
}
};
 
 
// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from shared_ptr<Y>
void
test01()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
 
a = std::shared_ptr<A>(new A);
VERIFY( a.get() != 0 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
 
a = std::shared_ptr<A>();
VERIFY( a.get() == 0 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 1 );
}
 
int
main()
{
test01();
return 0;
}
/assign/auto_ptr_neg.cc
0,0 → 1,51
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
struct B { };
 
// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from incompatible auto_ptr<Y>
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
std::auto_ptr<B> b;
a = std::move(b); // { dg-error "here" }
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
 
// { dg-prune-output "cannot convert" }
/assign/move.cc
0,0 → 1,118
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <utility>
#include <testsuite_hooks.h>
 
struct A
{
A() { ++ctor_count; }
virtual ~A() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long A::ctor_count = 0;
long A::dtor_count = 0;
 
struct B : A
{
B() { ++ctor_count; }
virtual ~B() { ++dtor_count; }
static long ctor_count;
static long dtor_count;
};
long B::ctor_count = 0;
long B::dtor_count = 0;
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
B::ctor_count = 0;
B::dtor_count = 0;
}
};
 
 
// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
 
// Rvalue assignment from shared_ptr
void
test01()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a1;
std::shared_ptr<A> a2(new A);
 
a1 = std::move(a2);
VERIFY( a1.get() != 0 );
VERIFY( a2.get() == 0 );
VERIFY( a1.use_count() == 1 );
VERIFY( a2.use_count() == 0 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
 
a1 = std::move(std::shared_ptr<A>());
VERIFY( a1.get() == 0 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 1 );
}
 
// Rvalue assignment from shared_ptr<Y>
void
test02()
{
reset_count_struct __attribute__((unused)) reset;
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
std::shared_ptr<B> b(new B);
 
a = std::move(b);
VERIFY( a.get() != 0 );
VERIFY( b.get() == 0 );
VERIFY( a.use_count() == 1 );
VERIFY( b.use_count() == 0 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 0 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 );
 
a = std::move(std::shared_ptr<A>());
VERIFY( a.get() == 0 );
VERIFY( A::ctor_count == 1 );
VERIFY( A::dtor_count == 1 );
VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 1 );
}
 
int
main()
{
test01();
test02();
return 0;
}
/assign/unique_ptr_rvalue.cc
0,0 → 1,61
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
std::unique_ptr<A> source() { return std::unique_ptr<A>(); }
 
// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
 
// Assignment from rvalue unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
a = source();
 
return 0;
}
 
int
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a;
std::unique_ptr<A> u;
a = std::move(u);
 
return 0;
}
 
int
main()
{
test01();
test02();
return 0;
}
/creation/dr402.cc
0,0 → 1,48
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <new>
#include <testsuite_hooks.h>
 
struct A
{
void* operator new(size_t n) { return new char[sizeof(A)]; }
void operator delete(void* p, size_t) { delete (char*)p; }
};
 
// 20.6.6.2.6 shared_ptr creation [util.smartptr.shared.create]
 
void
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p = std::make_shared<A>();
}
 
int
main()
{
test01();
return 0;
}
/creation/make.cc
0,0 → 1,97
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A(int i, double d, char c = '\0') : i(i), d(d), c(c) { ++ctor_count; }
explicit A(int i) : i(i), d(), c() { ++ctor_count; }
A() : i(), d(), c() { ++ctor_count; }
~A() { ++dtor_count; }
int i;
double d;
char c;
static int ctor_count;
static int dtor_count;
};
int A::ctor_count = 0;
int A::dtor_count = 0;
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
}
};
 
// 20.6.6.2.6 shared_ptr creation [util.smartptr.shared.create]
 
void
test01()
{
bool test __attribute__((unused)) = true;
reset_count_struct __attribute__((unused)) reset;
 
{
std::shared_ptr<A> p1 = std::make_shared<A>();
VERIFY( p1.get() != 0 );
VERIFY( p1.use_count() == 1 );
VERIFY( A::ctor_count == 1 );
}
VERIFY( A::ctor_count == A::dtor_count );
}
 
void
test02()
{
bool test __attribute__((unused)) = true;
reset_count_struct __attribute__((unused)) reset;
 
std::shared_ptr<A> p1;
p1 = std::make_shared<A>(1);
VERIFY( A::ctor_count == 1 );
 
p1 = std::make_shared<A>(1, 2.0);
VERIFY( A::ctor_count == 2 );
VERIFY( A::dtor_count == 1 );
 
p1 = std::make_shared<A>(1, 2.0, '3');
VERIFY( A::ctor_count == 3 );
VERIFY( A::dtor_count == 2 );
VERIFY( p1->i == 1 );
VERIFY( p1->d == 2.0 );
VERIFY( p1->c == '3' );
 
p1 = std::shared_ptr<A>();
VERIFY( A::ctor_count == A::dtor_count );
}
 
int
main()
{
test01();
test02();
}
/creation/alloc_min.cc
0,0 → 1,34
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.2.2 Class template shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_allocator.h>
 
struct X { };
 
// 20.7.2.2.6 shared_ptr creation [util.smartptr.shared.create]
 
// test shared_ptr with minimal allocator
 
__gnu_test::SimpleAllocator<X> alloc;
auto p = std::allocate_shared<X>(alloc);
 
/creation/36949.cc
0,0 → 1,34
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
#include <memory>
 
struct A : std::enable_shared_from_this<A> { };
 
// libstdc++/36949
void test01()
{
std::make_shared<A>()->shared_from_this();
}
 
int main()
{
test01();
return 0;
}
/creation/dr925.cc
0,0 → 1,90
// { dg-options "-std=gnu++0x -Wno-deprecated" }
 
// Copyright (C) 2010 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.9.11.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
};
 
std::unique_ptr<A>
create_unique_ptr()
{
return std::unique_ptr<A>(new A());
}
 
std::auto_ptr<A>
create_auto_ptr()
{
return std::auto_ptr<A>(new A());
}
 
void
process(std::shared_ptr<A> a)
{
bool test __attribute__((unused)) = true;
 
VERIFY( a.get() != 0 );
VERIFY( a.use_count() == 1 );
}
 
// 20.9.11.2.1 shared_ptr creation [util.smartptr.shared.const]
 
// Implicit conversion of auto_ptr to shared_ptr is allowed
 
void
test01()
{
process(create_auto_ptr());
}
 
void
test02()
{
std::auto_ptr<A> a = create_auto_ptr();
process(std::move(a));
}
 
// Implicit conversion of unique_ptr to shared_ptr is allowed
 
void
test03()
{
process(create_unique_ptr());
}
 
void
test04()
{
std::unique_ptr<A> a = create_unique_ptr();
process(std::move(a));
}
 
int
main()
{
test01();
test02();
test03();
test04();
return 0;
}
/creation/private.cc
0,0 → 1,52
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
#include <memory>
#include <new>
 
// The behaviour tested here relies on the resolution of LWG issue 2070
 
template<typename T> struct MyAlloc;
 
class Private
{
Private() = default;
Private(const Private&) = default;
~Private() = default;
 
friend class MyAlloc<Private>;
 
public:
int get() const { return 0; }
};
 
template<typename T>
struct MyAlloc : std::allocator<Private>
{
void construct(T* p) { ::new((void*)p) T(); }
void destroy(T* p) { p->~T(); }
};
 
int main()
{
MyAlloc<Private> a;
auto p = std::allocate_shared<Private>(a);
return p->get();
}
 
/creation/alloc.cc
0,0 → 1,110
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
 
using __gnu_test::tracker_allocator_counter;
using __gnu_test::tracker_allocator;
 
struct A
{
A(int i, double d, char c = '\0') : i(i), d(d), c(c) { ++ctor_count; }
explicit A(int i) : i(i), d(), c() { ++ctor_count; }
A() : i(), d(), c() { ++ctor_count; }
~A() { ++dtor_count; }
int i;
double d;
char c;
static int ctor_count;
static int dtor_count;
};
int A::ctor_count = 0;
int A::dtor_count = 0;
 
struct reset_count_struct
{
~reset_count_struct()
{
A::ctor_count = 0;
A::dtor_count = 0;
tracker_allocator_counter::reset();
}
};
 
// 20.6.6.2.6 shared_ptr creation [util.smartptr.shared.create]
 
void
test01()
{
bool test __attribute__((unused)) = true;
reset_count_struct __attribute__((unused)) reset;
 
{
std::shared_ptr<A> p1 = std::allocate_shared<A>(tracker_allocator<A>());
VERIFY( p1.get() != 0 );
VERIFY( p1.use_count() == 1 );
VERIFY( A::ctor_count == 1 );
VERIFY( tracker_allocator_counter::get_allocation_count() > 0 );
}
VERIFY( A::ctor_count == A::dtor_count );
VERIFY( tracker_allocator_counter::get_allocation_count()
== tracker_allocator_counter::get_deallocation_count() );
}
 
void
test02()
{
bool test __attribute__((unused)) = true;
reset_count_struct __attribute__((unused)) reset;
 
std::shared_ptr<A> p1;
p1 = std::allocate_shared<A>(tracker_allocator<A>(), 1);
VERIFY( A::ctor_count == 1 );
VERIFY( tracker_allocator_counter::get_allocation_count() > 0 );
 
p1 = std::allocate_shared<A>(tracker_allocator<A>(), 1, 2.0);
VERIFY( A::ctor_count == 2 );
VERIFY( A::dtor_count == 1 );
VERIFY( tracker_allocator_counter::get_deallocation_count() > 0 );
 
p1 = std::allocate_shared<A>(tracker_allocator<A>(), 1, 2.0, '3');
VERIFY( A::ctor_count == 3 );
VERIFY( A::dtor_count == 2 );
VERIFY( p1->i == 1 );
VERIFY( p1->d == 2.0 );
VERIFY( p1->c == '3' );
 
p1 = std::shared_ptr<A>();
VERIFY( A::ctor_count == A::dtor_count );
VERIFY( tracker_allocator_counter::get_allocation_count()
== tracker_allocator_counter::get_deallocation_count() );
}
 
int
main()
{
test01();
test02();
return 0;
}
/thread/mutex_weaktoshared.cc
0,0 → 1,199
// Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
// { dg-do run { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-solaris* *-*-cygwin *-*-darwin* alpha*-*-osf* mips-sgi-irix6* } }
// { dg-options " -std=gnu++0x -pthread" { target *-*-freebsd* *-*-netbsd* *-*-linux* alpha*-*-osf* mips-sgi-irix6* } }
// { dg-options " -std=gnu++0x -pthreads" { target *-*-solaris* } }
// { dg-options " -std=gnu++0x " { target *-*-cygwin *-*-darwin* } }
 
#include <memory>
#include <random>
#include <vector>
#include <testsuite_hooks.h>
#include <iostream>
#include <cstdlib>
 
#include <pthread.h>
 
#ifdef _GLIBCXX_HAVE_UNISTD_H
#include <unistd.h> // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
#endif
 
/* This (brute-force) tests the atomicity and thus thread safety of the
* shared_ptr <- weak_ptr
* assignment operation by allocating a test object, retrieving a weak
* reference to it, and letting a number of threads repeatedly create strong
* references from the weak reference.
* Specifically, this tests the function _Sp_counted_base<true>::add_ref_lock()
*/
 
 
const unsigned int HAMMER_MAX_THREADS = 10;
const unsigned int POOL_SIZE = 1000;
const unsigned long HAMMER_REPEAT = 100000;
const unsigned long KILL_ONE_IN = 1000;
 
struct A
{
static _Atomic_word counter;
A()
{
__gnu_cxx::__atomic_add(&counter, 1);
}
~A()
{
__gnu_cxx::__atomic_add(&counter, -1);
}
};
 
_Atomic_word A::counter = 0;
 
using std::_S_mutex;
 
typedef std::__shared_ptr<A, _S_mutex> sp_A_t;
typedef std::__weak_ptr<A, _S_mutex> wp_A_t;
 
typedef std::vector<sp_A_t> sp_vector_t;
typedef std::vector<wp_A_t> wp_vector_t;
 
struct shared_and_weak_pools
{
sp_vector_t& shared_pool;
wp_vector_t& weak_pool;
shared_and_weak_pools(sp_vector_t& _shared_pool, wp_vector_t& _weak_pool)
: shared_pool(_shared_pool), weak_pool(_weak_pool)
{ }
};
 
void* thread_hammer_and_kill(void* opaque_pools)
{
shared_and_weak_pools& pools = *static_cast<shared_and_weak_pools*>(opaque_pools);
// Using the same parameters as in the RNG test cases.
std::mersenne_twister_engine<
unsigned long, 32, 624, 397, 31,
0x9908b0dful, 11,
0xfffffffful, 7,
0x9d2c5680ul, 15,
0xefc60000ul, 18, 1812433253ul> rng;
 
sp_vector_t::iterator cur_shared = pools.shared_pool.begin();
wp_vector_t::iterator cur_weak = pools.weak_pool.begin();
for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
{
try
{
sp_A_t strong(*cur_weak);
}
catch (std::bad_weak_ptr& exception)
{
++cur_weak;
if (cur_weak == pools.weak_pool.end())
break;
}
if (rng() % KILL_ONE_IN == 0)
{
cur_shared->reset();
++cur_shared;
}
}
return 0;
}
 
void* thread_hammer(void* opaque_weak)
{
wp_vector_t& weak_pool = *static_cast<wp_vector_t*>(opaque_weak);
// Using the same parameters as in the RNG test cases.
std::mersenne_twister_engine<
unsigned long, 32, 624, 397, 31,
0x9908b0dful, 11,
0xfffffffful, 7,
0x9d2c5680ul, 15,
0xefc60000ul, 18, 1812433253ul> rng;
 
wp_vector_t::iterator cur_weak = weak_pool.begin();
 
for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
{
try
{
sp_A_t strong(*cur_weak);
}
catch (std::bad_weak_ptr& exception)
{
++cur_weak;
if (cur_weak == weak_pool.end())
break;
}
}
return 0;
}
 
int
test01()
{
bool test __attribute__((unused)) = true;
sp_vector_t obj_pool(POOL_SIZE);
for(sp_vector_t::iterator cur = obj_pool.begin(); cur != obj_pool.end(); ++cur)
{
cur->reset(new A);
}
// Obtain weak references.
std::vector<wp_vector_t> weak_pool(HAMMER_MAX_THREADS, wp_vector_t(obj_pool.begin(), obj_pool.end()));
// Launch threads with pointer to weak reference.
pthread_t threads[HAMMER_MAX_THREADS];
#if defined(__sun) && defined(__svr4__) && _XOPEN_VERSION >= 500
pthread_setconcurrency (HAMMER_MAX_THREADS);
#endif
pthread_attr_t tattr;
pthread_attr_init(&tattr);
 
shared_and_weak_pools pools(obj_pool, weak_pool[0]);
pthread_create(threads, &tattr, thread_hammer_and_kill, static_cast<void*>(&pools));
for (unsigned int worker = 1; worker < HAMMER_MAX_THREADS; worker++)
{
if (pthread_create(&threads[worker], &tattr,
thread_hammer, static_cast<void*>(&weak_pool[worker])))
std::abort();
}
// Wait for threads to complete, then check integrity of reference.
void* status;
for (unsigned int worker = 0; worker < HAMMER_MAX_THREADS; worker++)
{
if (pthread_join(threads[worker], &status))
std::abort();
}
obj_pool.clear();
VERIFY( A::counter == 0 );
return 0;
}
 
int
main()
{
test01();
return 0;
}
/thread/default_weaktoshared.cc
0,0 → 1,197
// Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
// { dg-do run { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-solaris* *-*-cygwin *-*-darwin* alpha*-*-osf* mips-sgi-irix6* } }
// { dg-options "-pthread -std=gnu++0x" { target *-*-freebsd* *-*-netbsd* *-*-linux* alpha*-*-osf* mips-sgi-irix6* } }
// { dg-options "-pthreads -std=gnu++0x" { target *-*-solaris* } }
// { dg-options " -std=gnu++0x " { target *-*-cygwin *-*-darwin* } }
 
#include <memory>
#include <random>
#include <vector>
#include <testsuite_hooks.h>
#include <iostream>
#include <cstdlib>
 
#include <pthread.h>
 
#ifdef _GLIBCXX_HAVE_UNISTD_H
#include <unistd.h> // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
#endif
 
/* This (brute-force) tests the atomicity and thus thread safety of the
* shared_ptr <- weak_ptr
* assignment operation by allocating a test object, retrieving a weak
* reference to it, and letting a number of threads repeatedly create strong
* references from the weak reference.
* Specifically, this tests the function _Sp_counted_base<true>::add_ref_lock()
*/
 
 
const unsigned int HAMMER_MAX_THREADS = 10;
const unsigned int POOL_SIZE = 1000;
const unsigned long HAMMER_REPEAT = 100000;
const unsigned long KILL_ONE_IN = 1000;
 
struct A
{
static _Atomic_word counter;
A()
{
__gnu_cxx::__atomic_add(&counter, 1);
}
~A()
{
__gnu_cxx::__atomic_add(&counter, -1);
}
};
 
_Atomic_word A::counter = 0;
 
typedef std::shared_ptr<A> sp_A_t;
typedef std::weak_ptr<A> wp_A_t;
 
typedef std::vector<sp_A_t> sp_vector_t;
typedef std::vector<wp_A_t> wp_vector_t;
 
struct shared_and_weak_pools
{
sp_vector_t& shared_pool;
wp_vector_t& weak_pool;
shared_and_weak_pools(sp_vector_t& _shared_pool, wp_vector_t& _weak_pool)
: shared_pool(_shared_pool), weak_pool(_weak_pool)
{ }
};
 
void* thread_hammer_and_kill(void* opaque_pools)
{
shared_and_weak_pools& pools = *static_cast<shared_and_weak_pools*>(opaque_pools);
// Using the same parameters as in the RNG test cases.
std::mersenne_twister_engine<
unsigned long, 32, 624, 397, 31,
0x9908b0dful, 11,
0xfffffffful, 7,
0x9d2c5680ul, 15,
0xefc60000ul, 18, 1812433253ul> rng;
sp_vector_t::iterator cur_shared = pools.shared_pool.begin();
wp_vector_t::iterator cur_weak = pools.weak_pool.begin();
for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
{
try
{
sp_A_t strong(*cur_weak);
}
catch (std::bad_weak_ptr& exception)
{
++cur_weak;
if (cur_weak == pools.weak_pool.end())
break;
}
if (rng() % KILL_ONE_IN == 0)
{
cur_shared->reset();
++cur_shared;
}
}
return 0;
}
 
void* thread_hammer(void* opaque_weak)
{
wp_vector_t& weak_pool = *static_cast<wp_vector_t*>(opaque_weak);
// Using the same parameters as in the RNG test cases.
std::mersenne_twister_engine<
unsigned long, 32, 624, 397, 31,
0x9908b0dful, 11,
0xfffffffful, 7,
0x9d2c5680ul, 15,
0xefc60000ul, 18, 1812433253ul> rng;
 
wp_vector_t::iterator cur_weak = weak_pool.begin();
 
for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
{
try
{
sp_A_t strong(*cur_weak);
}
catch (std::bad_weak_ptr& exception)
{
++cur_weak;
if (cur_weak == weak_pool.end())
break;
}
}
return 0;
}
 
int
test01()
{
bool test __attribute__((unused)) = true;
sp_vector_t obj_pool(POOL_SIZE);
for(sp_vector_t::iterator cur = obj_pool.begin(); cur != obj_pool.end(); ++cur)
{
cur->reset(new A);
}
// Obtain weak references.
std::vector<wp_vector_t> weak_pool(HAMMER_MAX_THREADS, wp_vector_t(obj_pool.begin(), obj_pool.end()));
// Launch threads with pointer to weak reference.
pthread_t threads[HAMMER_MAX_THREADS];
#if defined(__sun) && defined(__svr4__) && _XOPEN_VERSION >= 500
pthread_setconcurrency (HAMMER_MAX_THREADS);
#endif
pthread_attr_t tattr;
pthread_attr_init(&tattr);
 
shared_and_weak_pools pools(obj_pool, weak_pool[0]);
pthread_create(threads, &tattr, thread_hammer_and_kill, static_cast<void*>(&pools));
for (unsigned int worker = 1; worker < HAMMER_MAX_THREADS; worker++)
{
if (pthread_create(&threads[worker], &tattr,
thread_hammer, static_cast<void*>(&weak_pool[worker])))
std::abort();
}
// Wait for threads to complete, then check integrity of reference.
void* status;
for (unsigned int worker = 0; worker < HAMMER_MAX_THREADS; worker++)
{
if (pthread_join(threads[worker], &status))
std::abort();
}
obj_pool.clear();
VERIFY( A::counter == 0 );
return 0;
}
 
int
main()
{
test01();
return 0;
}
/comparison/dr1401.cc
0,0 → 1,65
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.7.2.2 Class template shared_ptr [util.smartptr.shared]
 
#include <memory>
 
// DR 1401
void test01()
{
std::shared_ptr<int> ptr1, ptr2;
if (ptr1 == ptr2)
{ }
if (ptr1 == nullptr)
{ }
if (nullptr == ptr1)
{ }
if (ptr1 != ptr2)
{ }
if (ptr1 != nullptr)
{ }
if (nullptr != ptr1)
{ }
if (ptr1 < ptr2)
{ }
if (ptr1 < nullptr)
{ }
if (nullptr < ptr1)
{ }
if (ptr1 <= ptr2)
{ }
if (ptr1 <= nullptr)
{ }
if (nullptr <= ptr1)
{ }
if (ptr1 > ptr2)
{ }
if (ptr1 > nullptr)
{ }
if (nullptr > ptr1)
{ }
if (ptr1 >= ptr2)
{ }
if (ptr1 >= nullptr)
{ }
if (nullptr >= ptr1)
{ }
}
/comparison/cmp.cc
0,0 → 1,88
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
virtual ~A() { }
};
 
struct B : A
{
};
 
// 20.6.6.2.6 shared_ptr comparison [util.smartptr.shared.cmp]
 
int
test01()
{
bool test __attribute__((unused)) = true;
 
// test empty shared_ptrs compare equivalent
std::shared_ptr<A> p1;
std::shared_ptr<B> p2;
VERIFY( p1 == p2 );
VERIFY( !(p1 != p2) );
VERIFY( !(p1 < p2) && !(p2 < p1) );
return 0;
}
 
 
// Construction from pointer
int
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> A_default;
 
std::shared_ptr<A> A_from_A(new A);
VERIFY( A_default != A_from_A );
VERIFY( !(A_default == A_from_A) );
VERIFY( (A_default < A_from_A) || (A_from_A < A_default) );
 
std::shared_ptr<B> B_from_B(new B);
VERIFY( B_from_B != A_from_A );
VERIFY( !(B_from_B == A_from_A) );
VERIFY( (B_from_B < A_from_A) || (A_from_A < B_from_B) );
 
A_from_A.reset();
VERIFY( A_default == A_from_A );
VERIFY( !(A_default != A_from_A) );
VERIFY( !(A_default < A_from_A) && !(A_from_A < A_default) );
 
B_from_B.reset();
VERIFY( B_from_B == A_from_A );
VERIFY( !(B_from_B != A_from_A) );
VERIFY( !(B_from_B < A_from_A) && !(A_from_A < B_from_B) );
 
return 0;
}
 
int
main()
{
test01();
test02();
return 0;
}
/comparison/42925.cc
0,0 → 1,37
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
 
// Copyright (C) 2010 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.9.11.2 Class template shared_ptr [util.smartptr.shared]
 
#include <memory>
 
// libstdc++/42925 (also see GB 99)
void test01()
{
std::shared_ptr<int> ptr;
if (ptr == 0)
{ }
if (0 == ptr)
{ }
if (ptr != 0)
{ }
if (0 != ptr)
{ }
}
/comparison/less.cc
0,0 → 1,102
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.8.13.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
namespace std
{
template<>
struct less<A*> : binary_function<A*,A*,bool>
{
static int count;
bool operator()(A* l, A* r) { ++count; return l < r; }
};
int less<A*>::count = 0;
}
 
// 20.8.13.2.7 shared_ptr comparison [util.smartptr.shared.cmp]
 
 
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::less<std::shared_ptr<A>> less;
// test empty shared_ptrs compare equivalent
std::shared_ptr<A> p1;
std::shared_ptr<A> p2;
VERIFY( !less(p1, p2) && !less(p2, p1) );
VERIFY( std::less<A*>::count == 2 );
return 0;
}
 
 
// Construction from pointer
int
test02()
{
bool test __attribute__((unused)) = true;
 
std::less<std::shared_ptr<A>> less;
 
std::shared_ptr<A> empty;
std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2(new A);
 
VERIFY( less(p1, p2) || less(p2, p1) );
VERIFY( !(less(p1, p2) && less(p2, p1)) );
 
p1.reset();
VERIFY( !less(p1, empty) && !less(empty, p1) );
 
p2.reset();
VERIFY( !less(p1, p2) && !less(p2, p1) );
 
return 0;
}
 
// Aliasing
int
test03()
{
bool test __attribute__((unused)) = true;
 
std::less<std::shared_ptr<A>> less;
 
A a;
std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2(p1, &a);
VERIFY( less(p1, p2) || less(p2, p1) );
 
return 0;
}
int
main()
{
test01();
test02();
test03();
return 0;
}
/observers/owner_before.cc
0,0 → 1,94
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.8.13.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
int i;
virtual ~A() { }
};
 
struct B : A
{
};
 
// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
 
void
test01()
{
bool test __attribute__((unused)) = true;
 
// test empty shared_ptrs compare equivalent
std::shared_ptr<A> p1;
std::shared_ptr<B> p2;
VERIFY( !p1.owner_before(p2) && !p2.owner_before(p1) );
}
 
 
// Construction from pointer
void
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> a0;
 
std::shared_ptr<A> a1(new A);
VERIFY( a1.owner_before(a0) || a0.owner_before(a1) );
VERIFY( !(a1.owner_before(a0) && a0.owner_before(a1)) );
 
std::shared_ptr<B> b1(new B);
VERIFY( a1.owner_before(b1) || b1.owner_before(a1) );
VERIFY( !(a1.owner_before(b1) && b1.owner_before(a1)) );
 
std::shared_ptr<A> a2(a1);
VERIFY( !a1.owner_before(a2) && !a2.owner_before(a1) );
a2 = b1;
VERIFY( !b1.owner_before(a2) && !a2.owner_before(b1) );
 
std::weak_ptr<A> w1(a1);
VERIFY( !a1.owner_before(w1) && !w1.owner_before(a1) );
std::weak_ptr<A> w2(a2);
VERIFY( !b1.owner_before(w2) && !w2.owner_before(b1) );
}
 
// Aliasing
void
test03()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p1(new A());
std::shared_ptr<int> p2(p1, &p1->i);
VERIFY( !p1.owner_before(p2) && !p2.owner_before(p1) );
}
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/observers/get.cc
0,0 → 1,73
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A
{
A() : i() {}
int i;
};
 
// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
 
// get
void
test01()
{
bool test __attribute__((unused)) = true;
 
A * const a = new A;
const std::shared_ptr<A> p(a);
VERIFY( p.get() == a );
}
 
// operator*
void
test02()
{
bool test __attribute__((unused)) = true;
 
A * const a = new A;
const std::shared_ptr<A> p(a);
VERIFY( &*p == a );
}
 
// operator->
void
test03()
{
bool test __attribute__((unused)) = true;
 
A * const a = new A;
const std::shared_ptr<A> p(a);
VERIFY( &p->i == &a->i );
}
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/observers/bool_conv.cc
0,0 → 1,75
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
 
// conversion to bool
void
test01()
{
bool test __attribute__((unused)) = true;
 
const std::shared_ptr<A> p1;
VERIFY( static_cast<bool>(p1) == false );
const std::shared_ptr<A> p2(p1);
VERIFY( static_cast<bool>(p2) == false );
}
 
void
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p1(new A);
VERIFY( static_cast<bool>(p1) );
std::shared_ptr<A> p2(p1);
VERIFY( static_cast<bool>(p2) );
p1.reset();
VERIFY( !static_cast<bool>(p1) );
VERIFY( static_cast<bool>(p2) );
}
 
void
test03()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2(p1);
p2.reset(new A);
VERIFY( static_cast<bool>(p1) );
VERIFY( static_cast<bool>(p2) );
}
 
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/observers/use_count.cc
0,0 → 1,74
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
struct B : A { };
 
// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
 
// use_count
void
test01()
{
bool test __attribute__((unused)) = true;
 
const std::shared_ptr<A> p1;
VERIFY( p1.use_count() == 0 );
const std::shared_ptr<A> p2(p1);
VERIFY( p1.use_count() == 0 );
}
 
void
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2(p1);
p1.reset();
VERIFY( p1.use_count() == 0 );
VERIFY( p2.use_count() == 1 );
}
 
void
test03()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2(p1);
p2.reset(new B);
VERIFY( p1.use_count() == 1 );
VERIFY( p2.use_count() == 1 );
}
 
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/observers/unique.cc
0,0 → 1,75
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
 
// unique
void
test01()
{
bool test __attribute__((unused)) = true;
 
const std::shared_ptr<A> p1;
VERIFY( !p1.unique() );
const std::shared_ptr<A> p2(p1);
VERIFY( !p1.unique() );
}
 
void
test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p1(new A);
VERIFY( p1.unique() );
std::shared_ptr<A> p2(p1);
VERIFY( !p1.unique() );
p1.reset();
VERIFY( !p1.unique() );
VERIFY( p2.unique() );
}
 
void
test03()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p1(new A);
std::shared_ptr<A> p2(p1);
p2.reset(new A);
VERIFY( p1.unique() );
VERIFY( p2.unique() );
}
 
 
int
main()
{
test01();
test02();
test03();
return 0;
}
/misc/42019.cc
0,0 → 1,56
// { dg-options "-std=gnu++0x -fno-rtti" }
// Copyright (C) 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.8.15.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
// libstdc++/42019
 
class A {};
 
struct B {
explicit B(int i) : i(i) { }
int i;
};
 
void test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> spA = std::make_shared<A>();
 
VERIFY( spA.get() != 0 );
}
 
void test02()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<B> spB = std::make_shared<B>(99);
 
VERIFY( spB->i == 99 );
}
 
int main()
{
test01();
test02();
return 0;
}
/misc/io.cc
0,0 → 1,52
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <sstream>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.8 shared_ptr I/O [util.smartptr.shared.io]
 
// operator<<
int
test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<A> p(new A);
std::ostringstream buf;
buf << p;
const std::string s = buf.str();
buf.str("");
buf << p.get();
VERIFY( s == buf.str() );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/misc/24595.cc
0,0 → 1,40
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
using std::get_deleter;
 
// libstdc++/24595
void test01()
{
bool test __attribute__((unused)) = true;
 
std::shared_ptr<int> sp;
VERIFY( !get_deleter<void(*)(int*)>(sp) );
}
 
int main()
{
test01();
return 0;
}
/misc/swap.cc
0,0 → 1,51
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
 
#include <memory>
#include <testsuite_hooks.h>
 
struct A { };
 
// 20.6.6.2.9 shared_ptr specialized algorithms [util.smartptr.shared.spec]
 
// std::swap
int
test01()
{
bool test __attribute__((unused)) = true;
 
A * const a1 = new A;
A * const a2 = new A;
std::shared_ptr<A> p1(a1);
std::shared_ptr<A> p2(a2);
std::swap(p1, p2);
VERIFY( p1.get() == a2 );
VERIFY( p2.get() == a1 );
 
return 0;
}
 
int
main()
{
test01();
return 0;
}
/casts/1.cc
0,0 → 1,45
// { dg-options "-std=gnu++0x" }
 
// Copyright (C) 2006, 2007, 2009 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
 
// 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
 
// 20.6.6.2.10 shared_ptr casts [util.smartptr.shared.cast]
 
#include <memory>
#include <testsuite_tr1.h>
 
// { dg-do compile }
 
struct MyP { virtual ~MyP() { }; };
struct MyDP : MyP { };
 
int main()
{
using __gnu_test::check_ret_type;
using std::shared_ptr;
using std::static_pointer_cast;
using std::const_pointer_cast;
using std::dynamic_pointer_cast;
 
shared_ptr<double> spd;
shared_ptr<const int> spci;
shared_ptr<MyP> spa;
 
check_ret_type<shared_ptr<void> >(static_pointer_cast<void>(spd));
check_ret_type<shared_ptr<int> >(const_pointer_cast<int>(spci));
check_ret_type<shared_ptr<MyDP> >(static_pointer_cast<MyDP>(spa));
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.