Add missing destructors to stubs

Author: jeongsoolee09

cpp/common/test/includes/standard-library/any.h

@@ -7,6 +7,7 @@ class any {
   any();
   any(const any &);
   any(any &&);
+  ~any();
   template <typename T> any(T &&);
 };
 

cpp/common/test/includes/standard-library/deque.h

@@ -18,6 +18,7 @@ template <class T, class Allocator = std::allocator<T>> class deque {
   deque(const deque &);
   deque(deque &&);
   deque(std::initializer_list<T>, const Allocator & = Allocator());
+  ~deque();
 
   typedef __iterator<T> iterator;
   typedef __iterator<T> const_iterator;

cpp/common/test/includes/standard-library/forward_list.h

@@ -12,6 +12,7 @@ template <typename T, typename Alloc = std::allocator<T>> class forward_list {
   forward_list(const forward_list &);
   forward_list(forward_list &&);
   forward_list(std::initializer_list<T>);
+  ~forward_list();
 };
 
 } // namespace std

cpp/common/test/includes/standard-library/fstream.h

@@ -12,6 +12,7 @@ class basic_fstream : public std::basic_iostream<CharT, Traits> {
   explicit basic_fstream(const char *s);
   basic_fstream(const basic_fstream &);
   basic_fstream(basic_fstream &&);
+  virtual ~basic_fstream();
   // members
   bool is_open() const;
   void open(const string &s);

cpp/common/test/includes/standard-library/functional.h

@@ -119,7 +119,9 @@ template <class R, class... Args> class function<R(Args...)> {
 public:
   using result_type = R; // deprecated in C++17
   function();
-  template <class F> function(F&& f);
+  template <class F> function(F &&f);
+  ~function();
+
   template <class F> function &operator=(F &&);
 };
 

cpp/common/test/includes/standard-library/future.h

@@ -14,6 +14,7 @@ class future {
     future();
     future(const future&);
     future(future&&);
+    ~future();
 };
 
 template<typename T>
@@ -23,6 +24,7 @@ class shared_future {
     shared_future(const shared_future&);
     shared_future(shared_future&&);
     shared_future(future<T>&&);
+    ~shared_future();
 };
 
 template<typename T>
@@ -31,6 +33,8 @@ class promise {
     promise();
     promise(const promise&);
     promise(promise&&);
+    ~promise();
+
     future<T> get_future();
 };
 
@@ -44,6 +48,7 @@ class packaged_task<R(Args...)> {
     packaged_task(const packaged_task&);
     packaged_task(packaged_task&&);
     template<typename F> packaged_task(F&&);
+    ~packaged_task();
 };
 
 template<typename F, typename... Args>

cpp/common/test/includes/standard-library/list.h

@@ -13,6 +13,7 @@ template <typename T, typename Alloc = std::allocator<T>> class list {
   list(const list &);
   list(list &&);
   list(std::initializer_list<T>);
+  ~list();
 };
 
 } // namespace std

cpp/common/test/includes/standard-library/map

@@ -14,6 +14,8 @@ public:
   multimap(const multimap&);
   multimap(multimap&&);
   multimap(std::initializer_list<std::pair<const _Key, _Tp>>);
+  ~multimap();
+
   typedef std::pair<const _Key, _Tp> value_type;
   typedef std::__iterator<value_type> iterator;
   typedef std::__iterator<value_type> const_iterator;
@@ -32,6 +34,8 @@ public:
   map(const map&);
   map(map&&);
   map(std::initializer_list<std::pair<const _Key, _Tp>>);
+  ~map();
+
   typedef std::pair<const _Key, _Tp> value_type;
   typedef std::__iterator<value_type> iterator;
   typedef std::__iterator<value_type> const_iterator;
@@ -41,4 +45,4 @@ public:
   const_iterator cbegin();
   const_iterator cend();
 };
-} // namespace std
+} // namespace std

cpp/common/test/includes/standard-library/memory.h

@@ -287,6 +287,7 @@ template <typename T> class weak_ptr {
   weak_ptr(const weak_ptr &);
   weak_ptr(weak_ptr &&);
   weak_ptr(const shared_ptr<T> &);
+  ~weak_ptr();
 };
 
 template <typename T, typename Alloc, typename... Args>

cpp/common/test/includes/standard-library/optional

@@ -36,6 +36,10 @@ public:
   constexpr optional(nullopt_t) noexcept;
   constexpr optional(const optional &other);
   constexpr optional(optional &&other) noexcept;
+
+  // Destructor
+  ~optional();
+
   template <class U> constexpr explicit optional(const optional<U> &other);
   template <class U> constexpr explicit optional(optional<U> &&other);
   template <class... Args>
@@ -45,9 +49,6 @@ public:
                               Args &&...args);
   template <class U = T> constexpr explicit optional(U &&value);
 
-  // Destructor
-  ~optional();
-
   // Assignment operators
   optional &operator=(nullopt_t) noexcept;
   constexpr optional &operator=(const optional &other);