Update shared_ptr tests to match the standard

[zoecarver]

Summary

This patch updates the shared_ptr tests so that they more closely and more completely match the standard. I think it is essential that these tests match exactly what the standard says and test it completely because I am going to use them when making significant changes to shared_ptr.

For reference here is the relevant section of the current standard.

Currently, I have only updated the constructor tests. However, I plan on updating all of the shared_ptr tests (either in this patch or another).

[EricWF]

There's a lot of whitespace changes here. And they hide what's actually changed. Would it be possible to generate a version of this patch without all the noise?

[zoecarver]

• white space
• a few test issues

[mclow.lists]

Zoe - you're not running these tests sufficiently.
They fail under c++03, c++11 and c++14

• min_allocator is a c++11-specific test tool.
• void_t is not available until C++17
• static_assert w/o a message is a C++17 thing.

[mclow.lists]

test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp

39

Two points here.

In C++03, we have an emulation of static_assert that is a macro. Sadly, like all macros, it gets confused by commas. "Is this a comma in the expression, or another macro parameter?" Hence, the extra parenthesis which you removed. Please put them back.

Also, why not use ASSERT_SAME_TYPE?

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp

27

Why braces here?

You might want to read up on the difference between default-initialization and value-initialization.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp

37

Is "whitespace" the only change to this file?

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp

39

By removing this space, you make it so it doesn't work in C++03.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp

72

min_allocator is a C++11 test thing.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp

72

I don't see any explanation as to why you're stripping out these C++03 tests.

96

I would think that this test should go on line 87

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_copy_move.fail.cpp

42

Why is this bit C++14 only?

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp

73

Again, why 14?

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp

10

Why disable this entire test for C++98/03?

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp

83

This comment is confusing to me.
It checks for +1, but the comment implies two.

(There should be only one allocation, btw).

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp

39

This seems convoluted. Why not:

std::shared_ptr<B> sp = std::dynamic_pointer_cast<B>(basePtr);
assert(sp);

[mclow.lists]

I should have flagged this before.

[zoecarver]

This patch is not the quality I would have liked. When I rolled back some of the changes I made, it left only whitespace changes which were not intentional. I also should have run the tests for 11, 14, and 17. When I updated this patch, I did not understand what versions of C++ shared_ptr was supported in. That is why I removed many of the C++11 checks and support for C++03 test cases. I will fix the issues around versioning and white space.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp

39

Will do.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp

27

This is to test that both work.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp

39

Because that would be ambiguous. Ugh, you are right. Will fix.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_copy_move.fail.cpp

42

Only since C++17 was this added:

This overload doesn't participate in overload resolution if std::unique_ptr<Y, Deleter>::pointer is not compatible with T*

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp

83

Oops, meant to get rid of this.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp

39

Yes, that would be simpler. I will update.

I originally wrote it in that way to match the note in the standard.

[zoecarver]

• remove spacing only changes
• fix versioning
• fix based on review

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp

96

The point is to assert both pA and pB point to nullptr. I can update.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp

73

This should be after C++17. This is testing the second overload for rvalue references: http://eel.is/c++draft/util.smartptr.shared#const-15

[zoecarver]

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp

27

This is the default.pass.cpp file. I see. Will remove.

[zoecarver]

• update tests based on the review
• general test fixes

[zoecarver]

Changed incorporated into D62259.

test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp

 //     typedef weak_ptr<T> weak_type; // C++17
 //     ...
 // };
 
 #include <memory>
 
 #include "test_macros.h"
 
+template<typename T, typename = std::void_t<>>
+struct has_less
+    : std::false_type
+{};
+
+template<typename T>
+struct has_less<T, std::void_t<decltype(std::declval<T>() < std::declval<T>())>>
+    : std::true_type
+{};
+
 struct A;  // purposefully incomplete
+struct B { int x = 42; };
 
-int main(int, char**)
+template<class T>
+void test()
 {
-    static_assert((std::is_same<std::shared_ptr<A>::element_type, A>::value), "");
+    static_assert(std::is_same<typename std::shared_ptr<T>::element_type, T>::value);
 #if TEST_STD_VER > 14
-    static_assert((std::is_same<std::shared_ptr<A>::weak_type, std::weak_ptr<A>>::value), "");
+    static_assert(std::is_same<typename std::shared_ptr<T>::weak_type, std::weak_ptr<T>>::value);
+    static_assert(std::is_copy_constructible<std::shared_ptr<T>>::value);
+    static_assert(std::is_copy_assignable<std::shared_ptr<T>>::value);
+    static_assert(has_less<std::shared_ptr<T>>::value);
+#if _LIBCPP_NEW_SHARED_PTR
+    static_assert(std::is_same<std::shared_ptr<T[]> ::element_type, T>::value);
+    static_assert(std::is_same<std::shared_ptr<T[8]>::element_type, T>::value);
 #endif
+#endif
+}
+
+int main(int, char**)
+{
+    test<A>();
+    test<B>();
+    test<int>();
+    test<char*>();
 
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr();
 
 #include <memory>
 #include <cassert>
 
-int main(int, char**)
+struct A { };
+
+template<class T>
+void test()
+{
+    {
+        std::shared_ptr<T> p;
+        assert(p.use_count() == 0);
+        assert(p.get() == 0);
+    }
     {
-    std::shared_ptr<int> p;
+        std::shared_ptr<T> p {};
         assert(p.use_count() == 0);
         assert(p.get() == 0);
+    }
+}
+
+int main(int, char**)
+{
+    test<int>();
+    test<A>();
+    test<int*>();
+//     test<int[]>();
+//     test<int[8]>();
 
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp

struct A
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
     {
         A* ptr = new A;
         std::shared_ptr<A> p(ptr);
         assert(A::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
     }
     assert(A::count == 0);
+
     {
         A* ptr = new A;
         std::shared_ptr<void> p(ptr);
         assert(A::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
     }
     assert(A::count == 0);
 
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp

struct A
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
     {
         A* ptr = new A;
         std::shared_ptr<A> p(ptr, test_deleter<A>(3));
         assert(A::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
-    test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
+
+        test_deleter<A>* d = std::get_deleter<test_deleter<A>>(p);
         assert(test_deleter<A>::count == 1);
         assert(test_deleter<A>::dealloc_count == 0);
         assert(d);
         assert(d->state() == 3);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
 
   return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp

struct A
 
     A() {++count;}
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
-
 int main(int, char**)
 {
+    // TODO: add tests for whatever the result of 41930 happens to be.
+
     {
         A* ptr = new A;
         std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5));
         assert(A::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
         test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
         assert(test_deleter<A>::count == 1);
         assert(test_deleter<A>::dealloc_count == 0);
         assert(d);
         assert(d->state() == 3);
         assert(test_allocator<A>::count == 1);
         assert(test_allocator<A>::alloc_count == 1);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
     assert(test_allocator<A>::count == 0);
     assert(test_allocator<A>::alloc_count == 0);
     test_deleter<A>::dealloc_count = 0;
+
     // Test an allocator with a minimal interface
     {
         A* ptr = new A;
         std::shared_ptr<A> p(ptr, test_deleter<A>(3), bare_allocator<void>());
         assert(A::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
         test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
         assert(test_deleter<A>::count == 1);
         assert(test_deleter<A>::dealloc_count == 0);
         assert(d);
         assert(d->state() == 3);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
     test_deleter<A>::dealloc_count = 0;
-#if TEST_STD_VER >= 11
+
     // Test an allocator that returns class-type pointers
     {
         A* ptr = new A;
         std::shared_ptr<A> p(ptr, test_deleter<A>(3), min_allocator<void>());
         assert(A::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
         test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
         assert(test_deleter<A>::count == 1);
         assert(test_deleter<A>::dealloc_count == 0);
         assert(d);
         assert(d->state() == 3);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
-#endif
 
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp

 
 int C::count = 0;
 
 int main(int, char**)
 {
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::shared_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<B>, std::shared_ptr<A> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<A>, std::shared_ptr<C> >::value), "");
+
     {
         std::shared_ptr<A> pA(new A);
         assert(pA.use_count() == 1);
         assert(B::count == 1);
         assert(A::count == 1);
         {
             B* p = pA.get();
             std::shared_ptr<B> pB(std::move(pA));
             assert(B::count == 1);
             assert(A::count == 1);
-#if TEST_STD_VER >= 11
             assert(pB.use_count() == 1);
             assert(pA.use_count() == 0);
-#else
-            assert(pB.use_count() == 2);
-            assert(pA.use_count() == 2);
-#endif
             assert(p == pB.get());
         }
-#if TEST_STD_VER >= 11
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
-#else
-        assert(pA.use_count() == 1);
-        assert(B::count == 1);
-        assert(A::count == 1);
-#endif
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
     {
         std::shared_ptr<A> pA;
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
         {
             std::shared_ptr<B> pB(pA);
             assert(B::count == 0);
             assert(A::count == 0);
             assert(pB.use_count() == 0);
             assert(pA.use_count() == 0);
             assert(pA.get() == pB.get());
+            assert(pA.get() == nullptr);
         }
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_copy_move.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// shared_ptr
+
+// template<class Y> shared_ptr(const shared_ptr<Y>& r);
+
+#include <memory>
+#include <type_traits>
+
+struct A { int x = 42; };
+
+struct ADel : std::default_delete<A>
+{
+    typedef A* pointer;
+};
+
+int main(int, char**)
+{
+    static_assert(!std::is_convertible<A, int>::value);
+
+    {
+        std::shared_ptr<A> pA;
+        std::shared_ptr<int> pi(pA); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+    {
+        std::shared_ptr<A> pA;
+        std::shared_ptr<int> pi(std::move(pA)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+    {
+        std::weak_ptr<A> pA;
+        std::shared_ptr<int> pi(std::move(pA)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+
+#if TEST_STD_VER > 14
+    {
+        std::unique_ptr<int, ADel> ui;
+        std::shared_ptr<int> pi(std::move(ui)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+#endif
+
+    return 0;
+}

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp

 
 int A::count = 0;
 
 int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
         assert(pA.use_count() == 1);
+
         {
             B b;
             std::shared_ptr<B> pB(pA, &b);
             assert(A::count == 1);
             assert(B::count == 1);
             assert(pA.use_count() == 2);
             assert(pB.use_count() == 2);
             assert(pB.get() == &b);
         }
         assert(pA.use_count() == 1);
         assert(A::count == 1);
         assert(B::count == 0);
     }
     assert(A::count == 0);
     assert(B::count == 0);
 
+    {
+        std::shared_ptr<int> p1(nullptr);
+        std::shared_ptr<int> p2(p1, new int);
+        assert(p2.get() != nullptr);
+    }
+    {
+        std::shared_ptr<int> p1(new int);
+        std::shared_ptr<int> p2(p1, nullptr);
+        assert(p2.get() == nullptr);
+    }
+
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A> pA(new A);
+        assert(pA.use_count() == 1);
+
+        {
+            B b;
+            std::shared_ptr<B> pB(std::move(pA), &b);
+            assert(A::count == 1);
+            assert(B::count == 1);
+            assert(pA.use_count() == 2);
+            assert(pB.use_count() == 2);
+            assert(pB.get() == &b);
+        }
+        assert(pA.use_count() == 1);
+        assert(A::count == 1);
+        assert(B::count == 0);
+    }
+    assert(A::count == 0);
+    assert(B::count == 0);
+#endif
+
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: sanitizer-new-delete
+// UNSUPPORTED: sanitizer-new-delete, c++98, c++03
+
 
 // <memory>
 
 // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);
 
 #include <memory>
 #include <new>
 #include <cstdlib>

 int A::count = 0;
 
 void fn ( const std::shared_ptr<int> &) {}
 void fn ( const std::shared_ptr<B> &) { assert (false); }
 
 template <typename T>
 void assert_deleter ( T * ) { assert(false); }
 
+template<class T>
+struct StatefulDeleter
+{
+    int state = 0;
+
+    StatefulDeleter(int val = 0) : state(val) {}
+    StatefulDeleter(StatefulDeleter const&) { assert(false); }
+
+    void operator()(T* ptr) {
+        assert(state == 42);
+        delete ptr;
+    }
+};
+
 int main(int, char**)
 {
     {
         std::unique_ptr<A> ptr(new A);
         A* raw_ptr = ptr.get();
         std::shared_ptr<B> p(std::move(ptr));
         assert(A::count == 1);
         assert(B::count == 1);
assert(A::count == 0);
         globalMemCounter.throw_after = 0;
         try
         {
             std::shared_ptr<B> p(std::move(ptr));
             assert(false);
         }
         catch (...)
         {
-#if TEST_STD_VER >= 11
             assert(A::count == 1);
             assert(B::count == 1);
             assert(ptr.get() == raw_ptr);
-#else
-            (void) raw_ptr; // silence 'unused variable' warning
-            assert(A::count == 0);
-            assert(B::count == 0);
-            assert(ptr.get() == 0);
-#endif
         }
     }
 #endif
+
+#if TEST_STD_VER > 14
+    {
+        std::unique_ptr<int> ptr;
+        std::shared_ptr<int> p(std::move(ptr));
+        assert(p.get() == 0);
+        assert(p.use_count() == 0);
+    }
+#endif
+
+    {
+        StatefulDeleter<A> d;
+        std::unique_ptr<A, StatefulDeleter<A>&> u(new A, d);
+        std::shared_ptr<A> p(std::move(u));
+        d.state = 42;
+        assert(A::count == 1);
+    }
     assert(A::count == 0);
+
     { // LWG 2399
         fn(std::unique_ptr<int>(new int));
     }
 #if TEST_STD_VER >= 14
     { // LWG 2415
         std::unique_ptr<int, void (*)(int*)> p(nullptr, assert_deleter<int>);
         std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
     }
 #endif
 
   return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp

 
 int main(int, char**)
 {
     int nc = globalMemCounter.outstanding_new;
     {
     int i = 67;
     char c = 'e';
     std::shared_ptr<A> p = std::make_shared<A>(i, c);
-    assert(globalMemCounter.checkOutstandingNewEq(nc+1));
+    assert(globalMemCounter.checkOutstandingNewEq(nc+1)); // one for make_shared (create type ptr) and one for creation of control block.
     assert(A::count == 1);
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');
     }
 
     { // https://bugs.llvm.org/show_bug.cgi?id=24137
     std::shared_ptr<Foo> p1       = std::make_shared<Foo>();
     assert(p1.get());

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp

 private:
    S () {};  // ctor is private
 };
 
 int main(int, char**)
 {
     std::shared_ptr<S> p = std::make_shared<S>();
 
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp

 
 struct S {
 protected:
    S () {};  // ctor is protected
 };
 
 int main(int, char**)
 {
-    std::shared_ptr<S> p = std::make_shared<S>();  // expected-error-re@memory:* {{static_assert failed{{.*}} "Can't construct object in make_shared"}}
+    std::shared_ptr<S> p = std::make_shared<S>(); // expected-error@memory:* {{static_assert failed due to requirement 'is_constructible<S>::value' "Can't construct object in make_shared"}}
 
   return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp

 
 // shared_ptr
 
 // explicit operator bool() const;
 
 #include <memory>
 #include <cassert>
 
+struct A
+{
+    int a;
+    virtual ~A() {};
+};
+struct B : A { };
+
 int main(int, char**)
 {
     {
         const std::shared_ptr<int> p(new int(32));
         assert(p);
     }
     {
         const std::shared_ptr<int> p;
         assert(!p);
     }
+    {
+        bool check = false;
+        std::shared_ptr<A> basePtr = std::make_shared<B>();
+
+        if (std::shared_ptr<B> sp = std::dynamic_pointer_cast<B>(basePtr))
+        { check = true; }
+
+        assert(check);
+    }
 
     return 0;
 }

test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp

 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
+        assert(pA.use_count() == 1);
         {
             std::weak_ptr<B> pB;
             pB = pA;
             assert(B::count == 1);
             assert(A::count == 1);
             assert(pB.use_count() == 1);
             assert(pA.use_count() == 1);
         }

test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp

assert(A::count == 0);
         std::shared_ptr<A> ps(new A);
         std::weak_ptr<A> pA = source(ps);
         std::weak_ptr<B> pB(std::move(pA));
         assert(pB.use_count() == 1);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
     return 0;
 }