From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 103707 invoked by alias); 26 Jul 2019 05:07:20 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 103605 invoked by uid 89); 26 Jul 2019 05:07:19 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-24.1 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.1 spammy= X-HELO: mail-wr1-f53.google.com Received: from mail-wr1-f53.google.com (HELO mail-wr1-f53.google.com) (209.85.221.53) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 26 Jul 2019 05:06:47 +0000 Received: by mail-wr1-f53.google.com with SMTP id n4so53019514wrs.3; Thu, 25 Jul 2019 22:06:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:subject:to:references:message-id:date:user-agent:mime-version :in-reply-to:content-language; bh=FFStucUVroozmZ3JZzN4BpgpBo1Cci8x8LIV4Qj+KwA=; b=PoRI55CQ7hdRpRAH9moiUEEE/Vh/edAN2lUXWgebW2ruEMCdNyvEWZxDNUVZiL/LOu fV1RCDWNIAI1oDHt5v3V2TWUu7Bs7nxZ/bgGHLsoM08MxHJzBG7iPeTGJ0Rb2a0ziueL O0H+IZaRlQnOi7Fim550w2zbOHtw5eSJ0Nd7Fbjh9SWHaKR0g3fq5pS8p+z7HGFkak9m Jt8HEZqb8Gk3BA7vh0JxYAdoNPOgOyITDHWeUK1XdUEhKzpqamPoAz1pGhu5nSvzqX4W Eh1KblOrDoi/T1Jq6/zwYFhkpNm7Bp6Ndo2hiNowRC/TRBjw6r7p4xHS3fMhU7COLZzQ JgkQ== Return-Path: Received: from [192.168.42.160] ([92.184.116.158]) by smtp.googlemail.com with ESMTPSA id p3sm42506058wmg.15.2019.07.25.22.06.42 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 25 Jul 2019 22:06:43 -0700 (PDT) From: =?UTF-8?Q?Fran=c3=a7ois_Dumont?= Subject: Re: PR 90409 Deque fiil/copy/move/copy_backward/move_backward/equal overloads To: "libstdc++@gcc.gnu.org" , gcc-patches References: <9357e741-9a71-6783-2ce9-24ba8a3939ba@gmail.com> Message-ID: <84aa6517-1f06-e751-e3ef-dcaea779806e@gmail.com> Date: Fri, 26 Jul 2019 09:13:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.8.0 MIME-Version: 1.0 In-Reply-To: <9357e741-9a71-6783-2ce9-24ba8a3939ba@gmail.com> Content-Type: multipart/mixed; boundary="------------E687385E247E3C8470735181" X-SW-Source: 2019-07/txt/msg01681.txt.bz2 This is a multi-part message in MIME format. --------------E687385E247E3C8470735181 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-length: 764 A new version with tests added at the right place, in 25_algorithms, next to the existing basic ones. Ok to commit ? François On 6/19/19 7:32 PM, François Dumont wrote: > I wanted to implement Debug overloads for those already existing > overloads but then realized that those algos could be generalized. > This way we will benefit from the memmove replacement when operating > with C array or std::array or std::vector iterators. > > I might do the same for lexicographical_compare one day. > > The ChangeLog below is quite huge so I attached it. I wonder if I > could use deque::iterator and deque::const_iterator in place of the > _Deque_iterator<> to reduce it ? > > Tested under Linux x86_64 normal and debug modes, ok to commit ? > > François > --------------E687385E247E3C8470735181 Content-Type: text/x-patch; name="deque_algos.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="deque_algos.patch" Content-length: 139762 diff --git a/libstdc++-v3/include/bits/deque.tcc b/libstdc++-v3/include/bits/deque.tcc index 3f77b4f079c..9db869fb666 100644 --- a/libstdc++-v3/include/bits/deque.tcc +++ b/libstdc++-v3/include/bits/deque.tcc @@ -967,155 +967,507 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); } +_GLIBCXX_END_NAMESPACE_CONTAINER + // Overload for deque::iterators, exploiting the "segmented-iterator // optimization". template void - fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first, - const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value) + fill(const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>& __first, + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>& __last, + const _Tp& __value) { - typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; - - for (typename _Self::_Map_pointer __node = __first._M_node + 1; - __node < __last._M_node; ++__node) - std::fill(*__node, *__node + _Self::_S_buffer_size(), __value); + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>::_Self + _Self; if (__first._M_node != __last._M_node) { std::fill(__first._M_cur, __first._M_last, __value); + + for (typename _Self::_Map_pointer __node = __first._M_node + 1; + __node < __last._M_node; ++__node) + std::fill(*__node, *__node + _Self::_S_buffer_size(), __value); + std::fill(__last._M_first, __last._M_cur, __value); } else std::fill(__first._M_cur, __last._M_cur, __value); } + namespace __detail + { + template + _OI + __copy_from_dit( + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __first, + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __last, + _OI __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>::_Self + _Self; + + if (__first._M_node != __last._M_node) + { + __result = std::copy(__first._M_cur, __first._M_last, __result); + + for (typename _Self::_Map_pointer __node = __first._M_node + 1; + __node != __last._M_node; ++__node) + __result = std::copy(*__node, *__node + _Self::_S_buffer_size(), + __result); + + return std::copy(__last._M_first, __last._M_cur, __result); + } + + return std::copy(__first._M_cur, __last._M_cur, __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + __copy_to_dit(_II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>::_Self + _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + const difference_type __clen + = std::min(__len, __result._M_last - __result._M_cur); + std::copy(__first, __first + __clen, __result._M_cur); + + __first += __clen; + __result += __clen; + __len -= __clen; + } + + return __result; + } + + template + _OI + __copy_backward_from_dit( + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __first, + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __last, + _OI __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>::_Self + _Self; + + if (__first._M_node != __last._M_node) + { + __result = std::copy_backward(__last._M_first, __last._M_cur, + __result); + + for (typename _Self::_Map_pointer __node = __last._M_node - 1; + __node != __first._M_node; --__node) + __result + = std::copy_backward(*__node, *__node + _Self::_S_buffer_size(), + __result); + + return std::copy_backward(__first._M_cur, __first._M_last, __result); + } + + return std::copy_backward(__first._M_cur, __last._M_cur, __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + __copy_backward_to_dit( + _II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>::_Self + _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + difference_type __rlen = __result._M_cur - __result._M_first; + _Tp* __rend = __result._M_cur; + if (!__rlen) + { + __rlen = _Self::_S_buffer_size(); + __rend = *(__result._M_node - 1) + __rlen; + } + + const difference_type __clen = std::min(__len, __rlen); + std::copy_backward(__last - __clen, __last, __rend); + + __last -= __clen; + __result -= __clen; + __len -= __clen; + } + + return __result; + } + + template + bool + __equal_from_dit( + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __first1, + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __last1, + _II __first2) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>::_Self + _Self; + + if (__first1._M_node != __last1._M_node) + { + if (!std::equal(__first1._M_cur, __first1._M_last, __first2)) + return false; + + __first2 += __first1._M_last - __first1._M_cur; + for (typename _Self::_Map_pointer __node = __first1._M_node + 1; + __node != __last1._M_node; + __first2 += _Self::_S_buffer_size(), ++__node) + if (!std::equal(*__node, *__node + _Self::_S_buffer_size(), __first2)) + return false; + + return std::equal(__last1._M_first, __last1._M_cur, __first2); + } + + return std::equal(__first1._M_cur, __last1._M_cur, __first2); + } + + template + bool + __equal_to_dit(_II __first1, _II __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first2) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>::_Self + _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last1 - __first1; + while (__len > 0) + { + const difference_type __clen + = std::min(__len, __first2._M_last - __first2._M_cur); + if (!std::equal(__first1, __first1 + __clen, __first2._M_cur)) + return false; + + __first1 += __clen; + __len -= __clen; + __first2 += __clen; + } + + return true; + } + +#if __cplusplus >= 201103L + template + _OI + __move_from_dit( + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __first, + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __last, + _OI __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>::_Self + _Self; + + if (__first._M_node != __last._M_node) + { + __result = std::move(__first._M_cur, __first._M_last, __result); + + for (typename _Self::_Map_pointer __node = __first._M_node + 1; + __node != __last._M_node; ++__node) + __result = std::move(*__node, *__node + _Self::_S_buffer_size(), + __result); + + return std::move(__last._M_first, __last._M_cur, __result); + } + + return std::move(__first._M_cur, __last._M_cur, __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + __move_to_dit(_II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>::_Self + _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + const difference_type __clen + = std::min(__len, __result._M_last - __result._M_cur); + std::move(__first, __first + __clen, __result._M_cur); + + __first += __clen; + __result += __clen; + __len -= __clen; + } + + return __result; + } + + template + _OI + __move_backward_from_dit( + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __first, + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>& __last, + _OI __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*>::_Self + _Self; + + if (__first._M_node != __last._M_node) + { + __result = std::move_backward(__last._M_first, __last._M_cur, + __result); + + for (typename _Self::_Map_pointer __node = __last._M_node - 1; + __node != __first._M_node; --__node) + __result + = std::move_backward(*__node, *__node + _Self::_S_buffer_size(), + __result); + + return std::move_backward(__first._M_cur, __first._M_last, __result); + } + + return std::move_backward(__first._M_cur, __last._M_cur, __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + __move_backward_to_dit( + _II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>::_Self + _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + difference_type __rlen = __result._M_cur - __result._M_first; + _Tp* __rend = __result._M_cur; + if (!__rlen) + { + __rlen = _Self::_S_buffer_size(); + __rend = *(__result._M_node - 1) + __rlen; + } + + const difference_type __clen = std::min(__len, __rlen); + std::move_backward(__last - __clen, __last, __rend); + + __last -= __clen; + __result -= __clen; + __len -= __clen; + } + + return __result; + } +#endif + } + + template + _OI + copy(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _OI __result) + { + __glibcxx_requires_can_increment_range(__first, __last, __result); + + return __detail::__copy_from_dit(__first, __last, __result); + } + template - _Deque_iterator<_Tp, _Tp&, _Tp*> - copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, - _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + copy(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) { - typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; - typedef typename _Self::difference_type difference_type; + __glibcxx_requires_can_increment_range(__first, __last, __result); - difference_type __len = __last - __first; - while (__len > 0) - { - const difference_type __clen - = std::min(__len, std::min(__first._M_last - __first._M_cur, - __result._M_last - __result._M_cur)); - std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur); - __first += __clen; - __result += __clen; - __len -= __clen; - } - return __result; + return __detail::__copy_from_dit(__first, __last, __result); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + copy(_II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + __glibcxx_requires_can_increment_range(__first, __last, __result); + + return __detail::__copy_to_dit(__first, __last, __result); + } + + template + _OI + copy_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _OI __result) + { + __glibcxx_requires_can_decrement_range(__first, __last, __result); + + return __detail::__copy_backward_from_dit(__first, __last, __result); } template - _Deque_iterator<_Tp, _Tp&, _Tp*> - copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, - _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + copy_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) { - typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; - typedef typename _Self::difference_type difference_type; + __glibcxx_requires_can_decrement_range(__first, __last, __result); - difference_type __len = __last - __first; - while (__len > 0) - { - difference_type __llen = __last._M_cur - __last._M_first; - _Tp* __lend = __last._M_cur; + return __detail::__copy_backward_from_dit(__first, __last, __result); + } - difference_type __rlen = __result._M_cur - __result._M_first; - _Tp* __rend = __result._M_cur; + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + copy_backward(_II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + __glibcxx_requires_can_decrement_range(__first, __last, __result); - if (!__llen) - { - __llen = _Self::_S_buffer_size(); - __lend = *(__last._M_node - 1) + __llen; - } - if (!__rlen) - { - __rlen = _Self::_S_buffer_size(); - __rend = *(__result._M_node - 1) + __rlen; - } + return __detail::__copy_backward_to_dit(__first, __last, __result); + } - const difference_type __clen = std::min(__len, - std::min(__llen, __rlen)); - std::copy_backward(__lend - __clen, __lend, __rend); - __last -= __clen; - __result -= __clen; - __len -= __clen; - } - return __result; + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last1, + _II __first2) + { + __glibcxx_requires_can_increment_range(__first1, __last1, __first2); + + return __detail::__equal_from_dit(__first1, __last1, __first2); } -#if __cplusplus >= 201103L template - _Deque_iterator<_Tp, _Tp&, _Tp*> - move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, - _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + bool + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first2) { - typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; - typedef typename _Self::difference_type difference_type; + __glibcxx_requires_can_increment_range(__first1, __last1, __first2); - difference_type __len = __last - __first; - while (__len > 0) - { - const difference_type __clen - = std::min(__len, std::min(__first._M_last - __first._M_cur, - __result._M_last - __result._M_cur)); - std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur); - __first += __clen; - __result += __clen; - __len -= __clen; - } - return __result; + return __detail::__equal_from_dit(__first1, __last1, __first2); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_II __first1, _II __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first2) + { + __glibcxx_requires_can_increment_range(__first1, __last1, __first2); + + return __detail::__equal_to_dit(__first1, __last1, __first2); + } + +#if __cplusplus >= 201103L + template + _OI + move(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _OI __result) + { + __glibcxx_requires_can_increment_range(__first, __last, __result); + + return __detail::__move_from_dit(__first, __last, __result); } template - _Deque_iterator<_Tp, _Tp&, _Tp*> - move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, - _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + move(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) { - typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; - typedef typename _Self::difference_type difference_type; + __glibcxx_requires_can_increment_range(__first, __last, __result); - difference_type __len = __last - __first; - while (__len > 0) - { - difference_type __llen = __last._M_cur - __last._M_first; - _Tp* __lend = __last._M_cur; + return __detail::__move_from_dit(__first, __last, __result); + } - difference_type __rlen = __result._M_cur - __result._M_first; - _Tp* __rend = __result._M_cur; + template + typename enable_if< + is_same::iterator_category, + std::random_access_iterator_tag>::value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::type + move(_II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + __glibcxx_requires_can_increment_range(__first, __last, __result); - if (!__llen) - { - __llen = _Self::_S_buffer_size(); - __lend = *(__last._M_node - 1) + __llen; - } - if (!__rlen) - { - __rlen = _Self::_S_buffer_size(); - __rend = *(__result._M_node - 1) + __rlen; - } + return __detail::__move_to_dit(__first, __last, __result); + } - const difference_type __clen = std::min(__len, - std::min(__llen, __rlen)); - std::move_backward(__lend - __clen, __lend, __rend); - __last -= __clen; - __result -= __clen; - __len -= __clen; - } - return __result; + template + _OI + move_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _OI __result) + { + __glibcxx_requires_can_decrement_range(__first, __last, __result); + + return __detail::__move_backward_from_dit(__first, __last, __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + move_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + __glibcxx_requires_can_decrement_range(__first, __last, __result); + + return __detail::__move_backward_from_dit(__first, __last, __result); + } + + template + typename enable_if< + is_same::iterator_category, + std::random_access_iterator_tag>::value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::type + move_backward(_II __first, _II __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + __glibcxx_requires_can_decrement_range(__first, __last, __result); + + return __detail::__move_backward_to_dit(__first, __last, __result); } #endif -_GLIBCXX_END_NAMESPACE_CONTAINER _GLIBCXX_END_NAMESPACE_VERSION } // namespace std diff --git a/libstdc++-v3/include/bits/stl_deque.h b/libstdc++-v3/include/bits/stl_deque.h index ac76d681ff0..23aea66c42c 100644 --- a/libstdc++-v3/include/bits/stl_deque.h +++ b/libstdc++-v3/include/bits/stl_deque.h @@ -370,77 +370,6 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER { return __x + __n; } }; - template - void - fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&, - const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&); - - template - _Deque_iterator<_Tp, _Tp&, _Tp*> - copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - inline _Deque_iterator<_Tp, _Tp&, _Tp*> - copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, - _Deque_iterator<_Tp, _Tp&, _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) - { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), - _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), - __result); } - - template - _Deque_iterator<_Tp, _Tp&, _Tp*> - copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - inline _Deque_iterator<_Tp, _Tp&, _Tp*> - copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, - _Deque_iterator<_Tp, _Tp&, _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) - { return std::copy_backward(_Deque_iterator<_Tp, - const _Tp&, const _Tp*>(__first), - _Deque_iterator<_Tp, - const _Tp&, const _Tp*>(__last), - __result); } - -#if __cplusplus >= 201103L - template - _Deque_iterator<_Tp, _Tp&, _Tp*> - move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - inline _Deque_iterator<_Tp, _Tp&, _Tp*> - move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, - _Deque_iterator<_Tp, _Tp&, _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) - { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), - _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), - __result); } - - template - _Deque_iterator<_Tp, _Tp&, _Tp*> - move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, const _Tp&, const _Tp*>, - _Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - inline _Deque_iterator<_Tp, _Tp&, _Tp*> - move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, - _Deque_iterator<_Tp, _Tp&, _Tp*> __last, - _Deque_iterator<_Tp, _Tp&, _Tp*> __result) - { return std::move_backward(_Deque_iterator<_Tp, - const _Tp&, const _Tp*>(__first), - _Deque_iterator<_Tp, - const _Tp&, const _Tp*>(__last), - __result); } -#endif - /** * Deque base class. This class provides the unified face for %deque's * allocation. This class's constructor and destructor allocate and @@ -2343,12 +2272,279 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _GLIBCXX_END_NAMESPACE_CONTAINER + template + void + fill(const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _Tp&); + + template + _OI + copy(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _OI); + + template + inline _OI + copy(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _OI __result) + { + return std::copy( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + copy(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + copy(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + return std::copy( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + copy(_II, _II, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + _OI + copy_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _OI); + + template + inline _OI + copy_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _OI __result) + { + return std::copy_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + copy_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + copy_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + return std::copy_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + copy_backward(_II, _II, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _II); + + template + inline typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last1, + _II __first2) + { + return std::equal( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first1), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last1), + __first2); + } + + template + bool + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>); + + template + inline bool + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first2) + { + return std::equal( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first1), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last1), + __first2); + } + + template + inline bool + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first2) + { + return std::equal( + __first1, __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first2)); + } + + template + inline bool + equal(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first2) + { + return std::equal( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first1), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last1), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first2)); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_II, _II, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>); + + template + inline typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_II __first1, _II __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first2) + { + return std::equal(__first1, __last1, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first2)); + } + #if __cplusplus >= 201103L // std::allocator is safe, but it is not the only allocator // for which this is valid. template struct __is_bitwise_relocatable<_GLIBCXX_STD_C::deque<_Tp>> : true_type { }; + + template + _OI + move(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _OI); + + template + inline _OI + move(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _OI __result) + { + return std::move( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + move(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + move(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + return std::move( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + typename enable_if< + is_same::iterator_category, + std::random_access_iterator_tag>::value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::type + move(_II, _II, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + _OI + move_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _OI); + + template + inline _OI + move_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _OI __result) + { + return std::move_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + move_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> + move_backward(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + return std::move_backward( + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); + } + + template + typename enable_if< + is_same::iterator_category, + std::random_access_iterator_tag>::value, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::type + move_backward(_II, _II, + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>); #endif _GLIBCXX_END_NAMESPACE_VERSION diff --git a/libstdc++-v3/include/debug/deque b/libstdc++-v3/include/debug/deque index 973f39fced6..64a29fbe1bc 100644 --- a/libstdc++-v3/include/debug/deque +++ b/libstdc++-v3/include/debug/deque @@ -685,6 +685,612 @@ namespace __debug { __lhs.swap(__rhs); } } // namespace __debug + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + void + fill(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __last, + const _Tp& __value) + { + __glibcxx_check_valid_range(__first, __last); + std::fill(__first.base(), __last.base(), __value); + } + + template + _OI + copy(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return std::copy(__first.base(), __last.base(), __result); + } + + template + _OI + copy(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return std::copy(__first.base(), __last.base(), __result); + } + + template + ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> > + copy(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >( + std::copy(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence()); + } + + template + ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> > + copy(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >( + std::copy(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence()); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> > >::__type + copy(_II __first, _II __last, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __result) + { + typename ::__gnu_debug::_Distance_traits<_II>::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >( + std::copy(::__gnu_debug::__unsafe(__first), + ::__gnu_debug::__unsafe(__last), __result.base()), + __result._M_get_sequence()); + } + + template + _OI + copy_backward( + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return std::copy_backward(__first.base(), __last.base(), __result); + } + + template + inline _OI + copy_backward( + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return std::copy_backward(__first.base(), __last.base(), __result); + } + + template + ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> > + copy_backward( + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >( + std::copy_backward(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence()); + } + + template + ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> > + copy_backward( + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >( + std::copy_backward(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence()); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> > >::__type + copy_backward(_II __first, _II __last, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __result) + { + typename ::__gnu_debug::_Distance_traits<_II>::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >( + std::copy_backward(::__gnu_debug::__unsafe(__first), + ::__gnu_debug::__unsafe(__last), + __result.base()), + __result._M_get_sequence()); + } + + template + inline typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >& __last1, + _II __first2) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> >::__type + __dist; + __glibcxx_check_valid_range2(__first1, __last1, __dist); + __glibcxx_check_can_increment(__first2, __dist.first); + + return std::equal(__first1.base(), __last1.base(), + ::__gnu_debug::__unsafe(__first2)); + } + + template + inline typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __last1, + _II __first2) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __dist; + __glibcxx_check_valid_range2(__first1, __last1, __dist); + __glibcxx_check_can_increment(__first2, __dist.first); + + return std::equal(__first1.base(), __last1.base(), + ::__gnu_debug::__unsafe(__first2)); + } + + template + bool + equal(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __first2) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> >::__type + __dist; + __glibcxx_check_valid_range2(__first1, __last1, __dist); + __glibcxx_check_can_increment(__first2, __dist.first); + + return std::equal(__first1.base(), __last1.base(), __first2.base()); + } + + template + bool + equal(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __first2) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __dist; + __glibcxx_check_valid_range2(__first1, __last1, __dist); + __glibcxx_check_can_increment(__first2, __dist.first); + + return std::equal(__first1.base(), __last1.base(), __first2.base()); + } + + template + bool + equal(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __first2) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*> >::__type + __dist; + __glibcxx_check_valid_range2(__first1, __last1, __dist); + __glibcxx_check_can_increment(__first2, __dist.first); + + return std::equal(__first1.base(), __last1.base(), __first2.base()); + } + + template + bool + equal(const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __first1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc1> >& __last1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc2> >& __first2) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __dist; + __glibcxx_check_valid_range2(__first1, __last1, __dist); + __glibcxx_check_can_increment(__first2, __dist.first); + + return std::equal(__first1.base(), __last1.base(), __first2.base()); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_II __first1, _II __last1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first2) + { + __glibcxx_check_can_increment_range(__first1, __last1, __first2); + + return std::equal(::__gnu_debug::__unsafe(__first1), + ::__gnu_debug::__unsafe(__last1), + __first2.base()); + } + + template + typename __gnu_cxx::__enable_if< + __are_same::iterator_category, + std::random_access_iterator_tag>::__value, + bool>::__type + equal(_II __first1, _II __last1, + const ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >& __first2) + { + __glibcxx_check_can_increment_range(__first1, __last1, __first2); + + return std::equal(::__gnu_debug::__unsafe(__first1), + ::__gnu_debug::__unsafe(__last1), + __first2.base()); + } + +#if __cplusplus >= 201103L + + namespace __detail + { + template + using _SDeque_iterator = ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>, + __debug::deque<_Tp, _Alloc> >; + + template + using _SDeque_const_iterator = ::__gnu_debug::_Safe_iterator< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + __debug::deque<_Tp, _Alloc> >; + } + + template + _OI + move(const __detail::_SDeque_const_iterator<_Tp, _Alloc>& __first, + const __detail::_SDeque_const_iterator<_Tp, _Alloc>& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return std::move(__first.base(), __last.base(), __result); + } + + template + _OI + move(const __detail::_SDeque_iterator<_Tp, _Alloc>& __first, + const __detail::_SDeque_iterator<_Tp, _Alloc>& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return std::move(__first.base(), __last.base(), __result); + } + + template + __detail::_SDeque_iterator<_Tp, _Alloc2> + move(const __detail::_SDeque_const_iterator<_Tp, _Alloc1>& __first, + const __detail::_SDeque_const_iterator<_Tp, _Alloc1>& __last, + const __detail::_SDeque_iterator<_Tp, _Alloc2>& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return + { + std::move(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence() + }; + } + + template + __detail::_SDeque_iterator<_Tp, _Alloc2> + move(const __detail::_SDeque_iterator<_Tp, _Alloc1>& __first, + const __detail::_SDeque_iterator<_Tp, _Alloc1>& __last, + const __detail::_SDeque_iterator<_Tp, _Alloc2>& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return + { + std::move(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence() + }; + } + + template + typename enable_if< + is_same::iterator_category, + std::random_access_iterator_tag>::value, + __detail::_SDeque_iterator<_Tp, _Alloc> >::type + move(_II __first, _II __last, + const __detail::_SDeque_iterator<_Tp, _Alloc>& __result) + { + typename ::__gnu_debug::_Distance_traits<_II>::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, __dist.first); + + return + { + std::move(::__gnu_debug::__unsafe(__first), + ::__gnu_debug::__unsafe(__last), __result.base()), + __result._M_get_sequence() + }; + } + + template + _OI + move_backward( + const __detail::_SDeque_const_iterator<_Tp, _Alloc>& __first, + const __detail::_SDeque_const_iterator<_Tp, _Alloc>& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return std::move_backward(__first.base(), __last.base(), __result); + } + + template + inline _OI + move_backward(const __detail::_SDeque_iterator<_Tp, _Alloc>& __first, + const __detail::_SDeque_iterator<_Tp, _Alloc>& __last, + _OI __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return std::move_backward(__first.base(), __last.base(), __result); + } + + template + __detail::_SDeque_iterator<_Tp, _Alloc2> + move_backward( + const __detail::_SDeque_const_iterator<_Tp, _Alloc1>& __first, + const __detail::_SDeque_const_iterator<_Tp, _Alloc1>& __last, + const __detail::_SDeque_iterator<_Tp, _Alloc2>& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, const _Tp&, + const _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return + { + std::move_backward(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence() + }; + } + + template + __detail::_SDeque_iterator<_Tp, _Alloc2> + move_backward( + const __detail::_SDeque_iterator<_Tp, _Alloc1>& __first, + const __detail::_SDeque_iterator<_Tp, _Alloc1>& __last, + const __detail::_SDeque_iterator<_Tp, _Alloc2>& __result) + { + typename ::__gnu_debug::_Distance_traits< + _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return + { + std::move_backward(__first.base(), __last.base(), __result.base()), + __result._M_get_sequence() + }; + } + + template + typename enable_if< + is_same::iterator_category, + std::random_access_iterator_tag>::value, + __detail::_SDeque_iterator<_Tp, _Alloc> >::type + move_backward(_II __first, _II __last, + const __detail::_SDeque_iterator<_Tp, _Alloc>& __result) + { + typename ::__gnu_debug::_Distance_traits<_II>::__type __dist; + __glibcxx_check_valid_range2(__first, __last, __dist); + __glibcxx_check_can_increment(__result, -__dist.first); + + return + { + std::move_backward(::__gnu_debug::__unsafe(__first), + ::__gnu_debug::__unsafe(__last), __result.base()), + __result._M_get_sequence() + }; + } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/11_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/11_neg.cc new file mode 100644 index 00000000000..86594da0102 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/11_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + + std::copy(d.begin() + 10, d.begin() + 5, dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/12_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/12_neg.cc new file mode 100644 index 00000000000..1507e8903a1 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/12_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + std::copy(d.begin(), d.end(), dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/2.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/2.cc new file mode 100644 index 00000000000..7b0dc3d2126 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/2.cc @@ -0,0 +1,109 @@ +// Copyright (C) 2019 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 +// . + +#include +#include +#include +#include + +#include + +void test01() +{ + using namespace std; + + deque d; + for (int i = 0; i != _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + copy(d.begin(), d.end(), dest.begin()); + + VERIFY( equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test02() +{ + using namespace std; + + deque d; + for (int i = 0; i != 4 * _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + const deque& cd = d; + copy(cd.begin(), cd.end(), dest.begin()); + + VERIFY( equal(dest.begin(), dest.end(), cd.begin()) ); +} + +void test03() +{ + using namespace std; + + deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + d.pop_front(); + d.pop_back(); + + vector dest(d.size(), 0); + + copy(d.begin(), d.end(), dest.begin()); + VERIFY( equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test04() +{ + using namespace std; + + vector v; + for (int i = 0; i != 1024; ++i) + v.push_back(i); + + deque dest(v.size() - 10, 0); + + std::copy(v.begin() + 5, v.end() - 5, dest.begin()); + VERIFY( std::equal(dest.begin(), dest.end(), v.begin() + 5) ); +} + +void test05() +{ + using namespace std; + + std::list l; + for (int i = 0; i != 1024; ++i) + l.push_back(i); + + std::deque dest(l.size(), 0); + + std::copy(l.begin(), l.end(), dest.begin()); + VERIFY( std::equal(dest.begin(), dest.end(), l.begin()) ); +} + +int main() +{ + test01(); + test02(); + test03(); + test04(); + test05(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/21_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/21_neg.cc new file mode 100644 index 00000000000..fc09f661b25 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/21_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + + const std::deque& cd = d; + copy(cd.begin() + 10, cd.begin() + 5, dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/22_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/22_neg.cc new file mode 100644 index 00000000000..64ff6c487e3 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/22_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + const std::deque& cd = d; + copy(cd.begin(), cd.end(), dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/31.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/31.cc new file mode 100644 index 00000000000..ae2c33b1d10 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/31.cc @@ -0,0 +1,43 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest(d.size(), 0); + + const std::deque& cd = d; + std::copy(cd.begin() + 10, cd.begin() + 5, dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/32.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/32.cc new file mode 100644 index 00000000000..8028bd6b542 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/32.cc @@ -0,0 +1,43 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest(d.size() / 2, 0); + + const std::deque& cd = d; + std::copy(cd.begin(), cd.end(), dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/33.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/33.cc new file mode 100644 index 00000000000..1633fafd20c --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/33.cc @@ -0,0 +1,57 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::list dest(d.size(), 0); + + const std::deque& cd = d; + std::copy(cd.begin(), cd.end(), dest.begin()); +} + +void test02() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::list dest(d.size() / 2, 0); + std::list::iterator lit = dest.begin(); + + const std::deque& cd = d; + std::copy(cd.begin(), cd.end(), ++lit); +} + +int main() +{ + test01(); + test02(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/41.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/41.cc new file mode 100644 index 00000000000..0c9d949807a --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/41.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest(d.size(), 0); + + std::copy(d.begin() + 10, d.begin() + 5, dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/42.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/42.cc new file mode 100644 index 00000000000..c7e0c1f49fd --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/42.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest(d.size() / 2, 0); + + std::copy(d.begin(), d.end(), dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/43.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/43.cc new file mode 100644 index 00000000000..2f29afae09f --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/43.cc @@ -0,0 +1,55 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::list dest(d.size(), 0); + + std::copy(d.begin(), d.end(), dest.begin()); +} + +void test02() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::list dest(d.size() / 2, 0); + std::list::iterator lit = dest.begin(); + + std::copy(d.begin(), d.end(), ++lit); +} + +int main() +{ + test01(); + test02(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/51_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/51_neg.cc new file mode 100644 index 00000000000..eaaa8b3d2d6 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/51_neg.cc @@ -0,0 +1,44 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest; + + const std::deque& cd = d; + std::copy(cd.begin() + 10, cd.begin() + 5, std::back_inserter(dest)); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/61_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/61_neg.cc new file mode 100644 index 00000000000..f6b20f6ee0e --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/61_neg.cc @@ -0,0 +1,43 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest; + + std::copy(d.begin() + 10, d.begin() + 5, std::back_inserter(dest)); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/71_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/71_neg.cc new file mode 100644 index 00000000000..063acf096f6 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/71_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::vector v; + for (int i = 0; i != 1024; ++i) + v.push_back(i); + + std::deque dest(v.size(), 0); + + std::copy(v.begin() + 10, v.begin() + 5, dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/72_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/72_neg.cc new file mode 100644 index 00000000000..855957ae1b6 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy/deque_iterators/72_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + std::vector v; + for (int i = 0; i != 1024; ++i) + v.push_back(i); + + std::deque dest(v.size() / 2, 0); + + std::copy(v.begin(), v.end(), dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/11_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/11_neg.cc new file mode 100644 index 00000000000..a497267f04f --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/11_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + + std::copy_backward(d.begin() + 10, d.begin() + 5, dest.end()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/12_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/12_neg.cc new file mode 100644 index 00000000000..f30d9f3c3b7 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/12_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + std::copy_backward(d.begin(), d.end(), dest.end()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/2.cc b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/2.cc new file mode 100644 index 00000000000..ccde5279859 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/2.cc @@ -0,0 +1,109 @@ +// Copyright (C) 2019 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 +// . + +#include +#include +#include +#include + +#include + +void test01() +{ + using namespace std; + + deque d; + for (int i = 0; i != _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + copy_backward(d.begin(), d.end(), dest.end()); + + VERIFY( equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test02() +{ + using namespace std; + + deque d; + for (int i = 0; i != 4 * _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + const deque& cd = d; + copy_backward(cd.begin(), cd.end(), dest.end()); + + VERIFY( equal(dest.begin(), dest.end(), cd.begin()) ); +} + +void test03() +{ + using namespace std; + + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + d.pop_front(); + d.pop_back(); + + std::vector dest(d.size(), 0); + + std::copy_backward(d.begin(), d.end(), dest.end()); + VERIFY( std::equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test04() +{ + using namespace std; + + std::vector v; + for (int i = 0; i != 1024; ++i) + v.push_back(i); + + std::deque dest(v.size() - 10, 0); + + std::copy_backward(v.begin() + 5, v.end() - 5, dest.end()); + VERIFY( std::equal(v.begin() + 5, v.end() - 5, dest.begin()) ); +} + +void test05() +{ + using namespace std; + + std::list l; + for (int i = 0; i != 1024; ++i) + l.push_back(i); + + std::deque dest(l.size(), 0); + + std::copy_backward(l.begin(), l.end(), dest.end()); + VERIFY( std::equal(dest.begin(), dest.end(), l.begin()) ); +} + +int main() +{ + test01(); + test02(); + test03(); + test04(); + test05(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/21_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/21_neg.cc new file mode 100644 index 00000000000..aec11a81172 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/21_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + + const std::deque& cd = d; + copy_backward(cd.begin() + 10, cd.begin() + 5, dest.end()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/22_neg.cc b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/22_neg.cc new file mode 100644 index 00000000000..89db2024ac9 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/copy_backward/deque_iterators/22_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + const std::deque& cd = d; + copy_backward(cd.begin(), cd.end(), dest.end()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/1.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/1.cc new file mode 100644 index 00000000000..b99cf1df538 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/1.cc @@ -0,0 +1,122 @@ +// Copyright (C) 2019 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 +// . + +#include +#include +#include + +#include +#include + +#include + +void test01() +{ + using namespace std; + + deque d; + for (int i = 0; i != _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + const deque& cd = d; + + VERIFY( equal(cd.begin(), cd.end(), cd.begin()) ); + VERIFY( equal(cd.begin(), cd.end(), d.begin()) ); + VERIFY( equal(d.begin(), d.end(), d.begin()) ); + VERIFY( equal(d.begin(), d.end(), cd.begin()) ); +} + +void test02() +{ + using namespace std; + + deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i % 10); + + VERIFY( equal(d.begin(), d.begin() + 10, d.begin() + 20) ); + VERIFY( equal(d.begin() + 10, d.end() - 10, d.begin()) ); + + const deque& cd = d; + + VERIFY( equal(cd.begin(), cd.begin() + 10, cd.begin() + 20) ); + VERIFY( equal(cd.begin() + 10, cd.end() - 10, d.begin()) ); + VERIFY( equal(d.begin() + 10, d.end() - 10, cd.begin()) ); +} + +void test03() +{ + using namespace std; + + deque d1; + for (int i = 0; i != 1024; ++i) + d1.push_back(i % 10); + + deque d2(d1); + for (int i = 0; i != 10; ++i) + d2.pop_front(); + + VERIFY( equal(d1.begin(), d1.begin() + 10, d2.begin()) ); + VERIFY( equal(d1.begin() + 10, d1.end() - 10, d2.begin()) ); + + const deque& cd1 = d1; + const deque& cd2 = d2; + + VERIFY( equal(cd1.begin(), cd1.begin() + 10, cd2.begin() + 20) ); + VERIFY( equal(cd1.begin() + 10, cd1.end() - 10, d2.begin()) ); + VERIFY( equal(cd2.begin() + 10, cd2.end() - 10, cd1.begin()) ); +} + +void test04() +{ + using namespace std; + + deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + vector v(d.begin(), d.end()); + + VERIFY( equal(d.begin(), d.end(), v.begin()) ); + VERIFY( equal(v.begin(), v.end(), d.begin()) ); + + const deque& cd = d; + + VERIFY( equal(cd.begin(), cd.end(), v.begin()) ); + VERIFY( equal(v.begin(), v.end(), cd.begin()) ); +} + +void test05() +{ + using namespace std; + + int a[] { 0, 1, 2, 3, 4 }; + deque > d1(a, a + 5); + deque > d2(a, a + 5); + + VERIFY( equal(d1.begin(), d1.end(), d2.begin()) ); +} + +int main() +{ + test01(); + test02(); + test03(); + test04(); + test05(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/10_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/10_neg.cc new file mode 100644 index 00000000000..72f070b292d --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/10_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(cd.begin(), cd.end(), d.begin() + 2) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/11_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/11_neg.cc new file mode 100644 index 00000000000..ae11f23d3b0 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/11_neg.cc @@ -0,0 +1,40 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + + VERIFY( equal(d.begin() + 2, d.begin(), d.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/12_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/12_neg.cc new file mode 100644 index 00000000000..a0c2cece818 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/12_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(d.begin(), d.end(), d.begin() + 2) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/13_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/13_neg.cc new file mode 100644 index 00000000000..b6f8519b1b2 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/13_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(a + 2, a, cd.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/14_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/14_neg.cc new file mode 100644 index 00000000000..6dfea283516 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/14_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(a, a + 3, cd.begin() + 2) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/15_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/15_neg.cc new file mode 100644 index 00000000000..fe0360a1842 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/15_neg.cc @@ -0,0 +1,40 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + + VERIFY( equal(a + 2, a, d.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/16_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/16_neg.cc new file mode 100644 index 00000000000..8330edc9b2e --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/16_neg.cc @@ -0,0 +1,40 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + + VERIFY( equal(a, a + 3, d.begin() + 2) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/1_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/1_neg.cc new file mode 100644 index 00000000000..1f26672b31d --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/1_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(cd.begin() + 2, cd.begin(), a) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/2_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/2_neg.cc new file mode 100644 index 00000000000..caadc2b77d1 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/2_neg.cc @@ -0,0 +1,43 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + vector v; + + VERIFY( equal(cd.begin(), cd.end(), v.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/3_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/3_neg.cc new file mode 100644 index 00000000000..55ed05c0ae5 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/3_neg.cc @@ -0,0 +1,40 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + + VERIFY( equal(d.begin() + 2, d.begin(), a) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/4_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/4_neg.cc new file mode 100644 index 00000000000..e67d4b19b42 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/4_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + vector v; + + VERIFY( equal(d.begin(), d.end(), v.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/5_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/5_neg.cc new file mode 100644 index 00000000000..d737aa2edfc --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/5_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(cd.begin() + 2, cd.begin(), cd.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/6_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/6_neg.cc new file mode 100644 index 00000000000..d1a74dd068a --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/6_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(cd.begin(), cd.end(), cd.begin() + 2) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/7_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/7_neg.cc new file mode 100644 index 00000000000..e3c9cf1325f --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/7_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(d.begin() + 2, d.begin(), cd.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/8_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/8_neg.cc new file mode 100644 index 00000000000..6078f598447 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/8_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(d.begin(), d.end(), cd.begin() + 2) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/9_neg.cc b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/9_neg.cc new file mode 100644 index 00000000000..7dd86ce3ec8 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/equal/deque_iterators/9_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + int a[] { 0, 1, 2 }; + deque d(a, a + 3); + const deque& cd = d; + + VERIFY( equal(cd.begin() + 2, cd.begin(), d.begin()) ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/fill/deque_iterators/1.cc b/libstdc++-v3/testsuite/25_algorithms/fill/deque_iterators/1.cc new file mode 100644 index 00000000000..604ccb67fcd --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/fill/deque_iterators/1.cc @@ -0,0 +1,58 @@ +// Copyright (C) 2019 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 +// . + +#include +#include + +#include + +void test01() +{ + using namespace std; + + deque d1; + for (int i = 0; i != _GLIBCXX_STD_C::__deque_buf_size(sizeof(char)); ++i) + d1.push_back((char)i); + + deque d2(d1.size(), '\0'); + + fill(d1.begin(), d1.end(), '\0'); + + VERIFY( equal(d1.begin(), d1.end(), d2.begin()) ); +} + +void test02() +{ + using namespace std; + + deque d1; + for (int i = 0; i != 4 * _GLIBCXX_STD_C::__deque_buf_size(sizeof(char)); ++i) + d1.push_back(i); + + deque d2(d1.size(), '\0'); + + fill(d1.begin(), d1.end(), '\0'); + + VERIFY( equal(d1.begin(), d1.end(), d2.begin()) ); +} + +int main() +{ + test01(); + test02(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/fill/deque_iterators/1_neg.cc b/libstdc++-v3/testsuite/25_algorithms/fill/deque_iterators/1_neg.cc new file mode 100644 index 00000000000..af25b2ef08a --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/fill/deque_iterators/1_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + using namespace std; + + deque d; + for (int i = 0; i != _GLIBCXX_STD_C::__deque_buf_size(sizeof(char)); ++i) + d.push_back((char)i); + + fill(d.begin() + 10, d.begin() + 5, '\0'); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/11_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/11_neg.cc new file mode 100644 index 00000000000..d3dc432ff7b --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/11_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + + std::move(d.begin() + 10, d.begin() + 5, dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/12_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/12_neg.cc new file mode 100644 index 00000000000..b4079691b7c --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/12_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + std::move(d.begin(), d.end(), dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/2.cc b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/2.cc new file mode 100644 index 00000000000..1f7930036d1 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/2.cc @@ -0,0 +1,101 @@ +// { dg-do run { target c++11 } } +// Copyright (C) 2019 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 +// . + +#include +#include +#include +#include + +#include + +void test01() +{ + using namespace std; + + deque d; + for (int i = 0; i != _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + move(d.begin(), d.end(), dest.begin()); + + VERIFY( equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test02() +{ + using namespace std; + + deque d; + for (int i = 0; i != 4 * _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + const deque& cd = d; + move(cd.begin(), cd.end(), dest.begin()); + + VERIFY( equal(dest.begin(), dest.end(), cd.begin()) ); +} + +void test03() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest(d.size(), 0); + + std::move(d.begin(), d.end(), dest.begin()); + VERIFY( std::equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test04() +{ + std::vector v; + for (int i = 0; i != 1024; ++i) + v.push_back(i); + + std::deque dest(v.size() - 10, 0); + + std::move(v.begin() + 5, v.end() - 5, dest.begin()); + VERIFY( std::equal(dest.begin(), dest.end(), v.begin() + 5) ); +} + +void test05() +{ + std::list l; + for (int i = 0; i != 1024; ++i) + l.push_back(i); + + std::deque dest(l.size(), 0); + + std::move(l.begin(), l.end(), dest.begin()); + VERIFY( std::equal(dest.begin(), dest.end(), l.begin()) ); +} + +int main() +{ + test01(); + test02(); + test03(); + test04(); + test05(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/21_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/21_neg.cc new file mode 100644 index 00000000000..66245fb677b --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/21_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + + const std::deque& cd = d; + move(cd.begin() + 10, cd.begin() + 5, dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/22_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/22_neg.cc new file mode 100644 index 00000000000..ab69e9bab77 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move/deque_iterators/22_neg.cc @@ -0,0 +1,42 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + const std::deque& cd = d; + move(cd.begin(), cd.end(), dest.begin()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/11_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/11_neg.cc new file mode 100644 index 00000000000..c5dbc14f8cc --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/11_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + + std::move_backward(d.begin() + 10, d.begin() + 5, dest.end()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/12_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/12_neg.cc new file mode 100644 index 00000000000..5718b5df141 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/12_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + std::move_backward(d.begin(), d.end(), dest.end()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/2.cc b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/2.cc new file mode 100644 index 00000000000..82fff3e20c8 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/2.cc @@ -0,0 +1,101 @@ +// { dg-do run { target c++11 } } +// Copyright (C) 2019 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 +// . + +#include +#include +#include +#include + +#include + +void test01() +{ + using namespace std; + + deque d; + for (int i = 0; i != _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + move_backward(d.begin(), d.end(), dest.end()); + + VERIFY( equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test02() +{ + using namespace std; + + deque d; + for (int i = 0; i != 4 * _GLIBCXX_STD_C::__deque_buf_size(sizeof(int)); ++i) + d.push_back(i); + + deque dest(d.size(), 0); + + const deque& cd = d; + move_backward(cd.begin(), cd.end(), dest.end()); + + VERIFY( equal(dest.begin(), dest.end(), cd.begin()) ); +} + +void test03() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::vector dest(d.size(), 0); + + std::move_backward(d.begin(), d.end(), dest.end()); + VERIFY( std::equal(dest.begin(), dest.end(), d.begin()) ); +} + +void test04() +{ + std::vector v; + for (int i = 0; i != 1024; ++i) + v.push_back(i); + + std::deque dest(v.size() - 10, 0); + + std::move_backward(v.begin() + 5, v.end() - 5, dest.end()); + VERIFY( std::equal(dest.begin(), dest.end(), v.begin() + 5) ); +} + +void test05() +{ + std::list l; + for (int i = 0; i != 1024; ++i) + l.push_back(i); + + std::deque dest(l.size(), 0); + + std::move_backward(l.begin(), l.end(), dest.end()); + VERIFY( std::equal(dest.begin(), dest.end(), l.begin()) ); +} + +int main() +{ + test01(); + test02(); + test03(); + test04(); + test05(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/21_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/21_neg.cc new file mode 100644 index 00000000000..002d879928e --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/21_neg.cc @@ -0,0 +1,40 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size(), 0); + move_backward(d.cbegin() + 10, d.cbegin() + 5, dest.end()); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/22_neg.cc b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/22_neg.cc new file mode 100644 index 00000000000..44cdfc84793 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/move_backward/deque_iterators/22_neg.cc @@ -0,0 +1,41 @@ +// Copyright (C) 2019 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 +// . +// +// { dg-do run { target c++11 xfail *-*-* } } +// { dg-require-debug-mode "" } + +#include +#include + +#include + +void test01() +{ + std::deque d; + for (int i = 0; i != 1024; ++i) + d.push_back(i); + + std::deque dest(d.size() / 2, 0); + + move_backward(d.cbegin(), d.cend(), dest.end()); +} + +int main() +{ + test01(); + return 0; +} --------------E687385E247E3C8470735181 Content-Type: text/plain; charset=UTF-8; name="ChangeLog.entry" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="ChangeLog.entry" Content-length: 20578 CSogaW5jbHVkZS9iaXRzL3N0bF9kZXF1ZS5oCgkoZmlsbCwgY29weSwgY29w eV9iYWNrd2FyZCwgbW92ZSwgbW92ZV9iYWNrd2FyZCk6IE1vdmUgb3Zlcmxv YWRzIGZvcgoJc3RkOjpkZXF1ZSBpdGVyYXRvcnMgaW4gc3RkIG5hbWVzcGFj ZS4KCShjb3B5PF9UcCwgX09JPigKCV9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNv bnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX0RlcXVlX2l0ZXJhdG9yPF9UcCwg Y29uc3QgX1RwJiwgY29uc3QgX1RwKj4sIF9PSSkpOiBOZXcuCgkoY29weTxf VHAsIF9PST4oX0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglf RGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwgX09JKSk6IE5ldywg dXNlIGxhdHRlci4KCShjb3B5PF9JSSwgX1RwPihfSUksIF9JSSwgX0RlcXVl X2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4pKTogTmV3LgoJKGNvcHlfYmFj a3dhcmQ8X1RwLCBfT0k+KF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9U cCYsIGNvbnN0IF9UcCo+LAoJX0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29uc3Qg X1RwJiwgY29uc3QgX1RwKj4sIF9PSSkpOiBOZXcuCgkoY29weV9iYWNrd2Fy ZDxfVHAsIF9PST4oX0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4s CglfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwgX09JKSk6IE5l dywgdXNlIGxhdHRlci4KCShjb3B5X2JhY2t3YXJkPF9JSSwgX1RwPihfSUks IF9JSSwgX0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4pKToKCU5l dy4KCShlcXVhbDxfVHAsIF9JST4oX0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29u c3QgX1RwJiwgY29uc3QgX1RwKj4sCglfRGVxdWVfaXRlcmF0b3I8X1RwLCBj b25zdCBfVHAmLCBjb25zdCBfVHAqPiwgX0lJKSk6IE5ldy4KCShlcXVhbDxf VHAsIF9JST4oX0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglf RGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwgX0lJKSk6IE5ldywg dXNlIGxhdHRlci4KCShlcXVhbDxfVHA+KF9EZXF1ZV9pdGVyYXRvcjxfVHAs IGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX0RlcXVlX2l0ZXJhdG9yPF9U cCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4sCglfRGVxdWVfaXRlcmF0b3I8 X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPikpOiBOZXcuCgkoZXF1YWw8 X1RwPihfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwKCV9EZXF1 ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX0RlcXVlX2l0ZXJhdG9y PF9UcCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4pKTogTmV3LCB1c2UgbGF0 dGVyLgoJKGVxdWFsPF9UcD4oX0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29uc3Qg X1RwJiwgY29uc3QgX1RwKj4sCglfRGVxdWVfaXRlcmF0b3I8X1RwLCBjb25z dCBfVHAmLCBjb25zdCBfVHAqPiwKCV9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9U cCYsIF9UcCo+KSk6IExpa2V3aXNlLgoJKGVxdWFsPF9UcD4oX0RlcXVlX2l0 ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglfRGVxdWVfaXRlcmF0b3I8X1Rw LCBfVHAmLCBfVHAqPiwgX0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1Rw Kj4pKToKCUxpa2V3aXNlLgoJKGVxdWFsPF9JSSwgX1RwPihfSUksIF9JSSwK CV9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+ KTogTmV3LgoJKGVxdWFsPF9JSSwgX1RwPihfSUksIF9JSSwgX0RlcXVlX2l0 ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4pOiBOZXcsIHVzZQoJbGF0dGVyLgoJ KG1vdmU8X1RwLCBfT0k+KF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9U cCYsIGNvbnN0IF9UcCo+LCBfT0kpKToKCU5ldy4KCShtb3ZlPF9UcCwgX09J PihfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwgX09JKSk6IE5l dywgdXNlCglsYXR0ZXIuCgkobW92ZTxfSUksIF9UcD4oX0lJLCBfSUksIF9E ZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+KSk6IE5ldy4KCShtb3Zl X2JhY2t3YXJkPF9UcCwgX09JPihfRGVxdWVfaXRlcmF0b3I8X1RwLCBjb25z dCBfVHAmLCBjb25zdCBfVHAqPiwKCV9PSSkpOiBOZXcuCgkobW92ZV9iYWNr d2FyZDxfVHAsIF9PST4oX0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1Rw Kj4sIF9PSSkpOiBOZXcsCgl1c2UgbGF0dGVyLgoJKG1vdmVfYmFja3dhcmQ8 X0lJLCBfVHA+KF9JSSwgX0lJLCBfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAm LCBfVHAqPikpOgoJTmV3LgoJKiBpbmNsdWRlL2JpdHMvZGVxdWUudGNjCgko ZmlsbCwgY29weSwgY29weV9iYWNrd2FyZCwgbW92ZSwgbW92ZV9iYWNrd2Fy ZCk6IE1vdmUgb3ZlcmxvYWRzIGZvcgoJc3RkOjpkZXF1ZSBpdGVyYXRvcnMg aW4gc3RkIG5hbWVzcGFjZS4KCShmaWxsKTogTW92ZSBsb29wIG9uIG5vZGVz IGluc2lkZSBicmFuY2ggd2hlbiBmaXJzdCBhbmQgbGFzdCBub2RlcyBhcmUK CWRpZmZlcmVudC4KCShzdGQ6Ol9fZGV0YWlsOjpfX2NvcHlfZnJvbV9kaXQp OiBOZXcuCgkoY29weTxfVHA+KF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0 IF9UcCYsIGNvbnN0IF9UcCo+LAoJX0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29u c3QgX1RwJiwgY29uc3QgX1RwKj4sCglfRGVxdWVfaXRlcmF0b3I8X1RwLCBf VHAmLCBfVHAqPikpOiBBZGFwdCB0byB1c2UgbGF0dGVyLgoJKGNvcHk8X1Rw LCBfT0k+KF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0 IF9UcCo+LAoJX0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29uc3QgX1RwJiwgY29u c3QgX1RwKj4sIF9PSSkpOiBOZXcsIGxpa2V3aXNlLgoJKHN0ZDo6X19kZXRh aWw6Ol9fY29weV90b19kaXQpOiBOZXcuCgkoY29weTxfSUksIF9UcD4oX0lJ LCBfSUksIF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+KSk6IE5l dywgdXNlCglsYXR0ZXIuCgkoc3RkOjpfX2RldGFpbDo6X19jb3B5X2JhY2t3 YXJkX2Zyb21fZGl0KTogTmV3LgoJKGNvcHlfYmFja3dhcmQ8X1RwPihfRGVx dWVfaXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9E ZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJ X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4pKTogQWRhcHQgdG8g dXNlIGxhdHRlci4KCShjb3B5X2JhY2t3YXJkPF9UcCwgX09JPihfRGVxdWVf aXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9EZXF1 ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LCBfT0kp KTogTmV3LCBsaWtld2lzZS4KCShzdGQ6Ol9fZGV0YWlsOjpfX2NvcHlfYmFj a3dhcmRfdG9fZGl0KTogTmV3LgoJKGNvcHlfYmFja3dhcmQ8X0lJLCBfVHA+ KF9JSSwgX0lJLCBfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPikp OgoJTmV3LCB1c2UgbGF0dGVyLgoJKHN0ZDo6X19kZXRhaWw6Ol9fZXF1YWxf ZnJvbV9kaXQpOiBOZXcuCgkoZXF1YWw8X1RwLCBfSUk+KF9EZXF1ZV9pdGVy YXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX0RlcXVlX2l0 ZXJhdG9yPF9UcCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4sCglfRGVxdWVf aXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPikpOiBVc2Ug bGF0dGVyLgoJKGVxdWFsPF9UcCwgX0lJPihfRGVxdWVfaXRlcmF0b3I8X1Rw LCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9EZXF1ZV9pdGVyYXRvcjxf VHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LCBfSUkpKTogTmV3LCBsaWtl d2lzZS4KCShzdGQ6Ol9fZGV0YWlsOjpfX2VxdWFsX3RvX2RpdCk6IE5ldy4K CShlcXVhbDxfSUksIF9UcD4oX0lJLCBfSUksCglfRGVxdWVfaXRlcmF0b3I8 X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPik6IE5ldywgdXNlIGxhdHRl ci4KCShzdGQ6Ol9fZGV0YWlsOjpfX21vdmVfZnJvbV9kaXQpOiBOZXcuCgko bW92ZTxfVHA+KF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNv bnN0IF9UcCo+LAoJX0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29uc3QgX1RwJiwg Y29uc3QgX1RwKj4sCglfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAq PikpOiBBZGFwdCB0byB1c2UgbGF0dGVyLgoJKG1vdmU8X1RwLCBfT0k+KF9E ZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJ X0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4s IF9PSSkpOiBOZXcsIGxpa2V3aXNlLgoJKHN0ZDo6X19kZXRhaWw6Ol9fbW92 ZV90b19kaXQpOiBOZXcuCgkobW92ZTxfSUksIF9UcD4oX0lJLCBfSUksIF9E ZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+KSk6IE5ldywgdXNlCgls YXR0ZXIuCgkoc3RkOjpfX2RldGFpbDo6X19tb3ZlX2JhY2t3YXJkX2Zyb21f ZGl0KTogTmV3LgoJKG1vdmVfYmFja3dhcmQ8X1RwPihfRGVxdWVfaXRlcmF0 b3I8X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9EZXF1ZV9pdGVy YXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX0RlcXVlX2l0 ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4pKTogQWRhcHQgdG8gdXNlIGxhdHRl ci4KCShtb3ZlX2JhY2t3YXJkPF9UcCwgX09JPihfRGVxdWVfaXRlcmF0b3I8 X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9EZXF1ZV9pdGVyYXRv cjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LCBfT0kpKTogTmV3LCBs aWtld2lzZS4KCShzdGQ6Ol9fZGV0YWlsOjpfX21vdmVfYmFja3dhcmRfdG9f ZGl0KTogTmV3LgoJKG1vdmVfYmFja3dhcmQ8X0lJLCBfVHA+KF9JSSwgX0lJ LCBfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPikpOgoJTmV3LCB1 c2UgbGF0dGVyLgoJKiBpbmNsdWRlL2RlYnVnL2RlcXVlCgkoZmlsbDxfVHAs IF9BbGxvYz4oY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9y PF9UcCwgX1RwJiwgX1RwKj4KCSwgX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxs b2M+PiYsCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8 X1RwLCBfVHAmLCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9j Pj4mLCBjb25zdCBfVHAmKSk6IE5ldy4KCShjb3B5PF9UcCwgX0FsbG9jLCBf T0k+KAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9U cCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4sCglfX2RlYnVnOjpkZXF1ZTxf VHAsIF9BbGxvYz4gPiYsCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVf aXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9fZGVi dWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+JiwgX09JKSk6IE5ldy4KCShjb3B5 PF9UcCwgX0FsbG9jLCBfT0k+KAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0Rl cXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglfX2RlYnVnOjpkZXF1 ZTxfVHAsIF9BbGxvYz4gPiYsCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVx dWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwKCV9fZGVidWc6OmRlcXVl PF9UcCwgX0FsbG9jPiA+JiwgX09JKSk6IE5ldy4KCShjb3B5PF9UcCwgX0Fs bG9jPigKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxf VHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8 X1RwLCBfQWxsb2M+ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVl X2l0ZXJhdG9yPF9UcCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4sCglfX2Rl YnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYsCgljb25zdCBfU2FmZV9pdGVy YXRvcjxfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwKCV9fZGVi dWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+JikpOiBOZXcuCgkoY29weTxfVHAs IF9BbGxvYz4oCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0 b3I8X1RwLCBfVHAmLCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0Fs bG9jPiA+JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRv cjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxs b2M+ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9y PF9UcCwgX1RwJiwgX1RwKj4sCglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxv Yz4gPiYpKTogTmV3LgoJKGNvcHk8X0lJLCBfVHAsIF9BbGxvYz4oX0lJLCBf SUksCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8X1Rw LCBfVHAmLCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+ JikpOiBOZXcuCgkoY29weV9iYWNrd2FyZDxfVHAsIF9BbGxvYywgX09JPigK CWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNv bnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBf QWxsb2M+ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJh dG9yPF9UcCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4sCglfX2RlYnVnOjpk ZXF1ZTxfVHAsIF9BbGxvYz4gPiYsIF9PSSkpOiBOZXcuCgkoY29weV9iYWNr d2FyZDxfVHAsIF9BbGxvYywgX09JPigKCWNvbnN0IF9TYWZlX2l0ZXJhdG9y PF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6 ZGVxdWU8X1RwLCBfQWxsb2M+ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8 X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglfX2RlYnVnOjpk ZXF1ZTxfVHAsIF9BbGxvYz4gPiYsIF9PSSkpOiBOZXcuCgkoY29weV9iYWNr d2FyZDxfVHAsIF9BbGxvYz4oCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVx dWVfaXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9f ZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+JiwKCWNvbnN0IF9TYWZlX2l0 ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0 IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2M+ID4mLAoJY29u c3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwg X1RwKj4sCglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYpKTogTmV3 LgoJKGNvcHlfYmFja3dhcmQ8X1RwLCBfQWxsb2M+KAoJY29uc3QgX1NhZmVf aXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglf X2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYsCgljb25zdCBfU2FmZV9p dGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwKCV9f ZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+JiwKCWNvbnN0IF9TYWZlX2l0 ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19k ZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2M+ID4mKSk6IE5ldy4KCShjb3B5X2Jh Y2t3YXJkPF9JSSwgX1RwLCBfQWxsb2M+KF9JSSwgX0lJLAoJY29uc3QgX1Nh ZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4s CglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYpKTogTmV3LgoJKGVx dWFsPF9UcCwgX0FsbG9jLCBfSUk+KAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8 X0RlcXVlX2l0ZXJhdG9yPF9UcCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4s CglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYsCgljb25zdCBfU2Fm ZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBj b25zdCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+Jiwg X0lJKSk6IE5ldy4KCShlcXVhbDxfVHAsIF9BbGxvYywgX0lJPigKCWNvbnN0 IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9U cCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2M+ID4mLAoJY29uc3Qg X1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1Rw Kj4sCglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYsIF9JSSkpOiBO ZXcuCgkoZXF1YWw8X1RwLCBfQWxsb2MxLCBfQWxsb2MyPigKCWNvbnN0IF9T YWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYs IGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2MxPiA+ JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAs IGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1Rw LCBfQWxsb2MxPiA+JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9p dGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1 Zzo6ZGVxdWU8X1RwLCBfQWxsb2MyPiA+JikpOiBOZXcuCgkoZXF1YWw8X1Rw LCBfQWxsb2MxLCBfQWxsb2MyPigKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9E ZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVx dWU8X1RwLCBfQWxsb2MxPiA+JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9E ZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVx dWU8X1RwLCBfQWxsb2MxPiA+JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9E ZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJ X19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2MyPiA+JikpOiBOZXcuCgkoZXF1 YWw8X1RwLCBfQWxsb2MxLCBfQWxsb2MyPigKCWNvbnN0IF9TYWZlX2l0ZXJh dG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9U cCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2MxPiA+JiwKCWNvbnN0 IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9U cCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2Mx PiA+JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxf VHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2My PiA+JikpOiBOZXcuCgkoZXF1YWw8X1RwLCBfQWxsb2MxLCBfQWxsb2MyPigK CWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9U cCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2MxPiA+JiwK CWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9U cCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2MxPiA+JiwK CWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9U cCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2MyPiA+Jikp OiBOZXcuCgkoZXF1YWw8X0lJLCBfVHAsIF9BbGxvYz4oX0lJLCBfSUksCglj b25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8X1RwLCBjb25z dCBfVHAmLCBjb25zdCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0Fs bG9jPiA+JikpOiBOZXcuCgkoZXF1YWw8X0lJLCBfVHAsIF9BbGxvYz4oX0lJ LCBfSUksCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8 X1RwLCBfVHAmLCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9j PiA+JikpOiBOZXcuCgkobW92ZTxfVHAsIF9BbGxvYywgX09JPigKCWNvbnN0 IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNvbnN0IF9U cCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2M+ ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9U cCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4sCglfX2RlYnVnOjpkZXF1ZTxf VHAsIF9BbGxvYz4gPiYsIF9PSSkpOiBOZXcuCgkobW92ZTxfVHAsIF9BbGxv YywgX09JPigKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRv cjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxs b2M+ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9y PF9UcCwgX1RwJiwgX1RwKj4sCglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxv Yz4gPiYsIF9PSSkpOiBOZXcuCgkobW92ZTxfVHAsIF9BbGxvYz4oCgljb25z dCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8X1RwLCBjb25zdCBf VHAmLCBjb25zdCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9j PiA+JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxf VHAsIGNvbnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8 X1RwLCBfQWxsb2M+ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVl X2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglfX2RlYnVnOjpkZXF1ZTxf VHAsIF9BbGxvYz4gPiYpKTogTmV3LgoJKG1vdmU8X1RwLCBfQWxsb2M+KAoJ Y29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1Rw JiwgX1RwKj4sCglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYsCglj b25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8X1RwLCBfVHAm LCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+JiwKCWNv bnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYs IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2M+ID4mKSk6IE5l dy4KCShtb3ZlPF9JSSwgX1RwLCBfQWxsb2M+KF9JSSwgX0lJLAoJY29uc3Qg X1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1Rw Kj4sCglfX2RlYnVnOjpkZXF1ZTxfVHAsIF9BbGxvYz4gPiYpKTogTmV3LgoJ KG1vdmVfYmFja3dhcmQ8X1RwLCBfQWxsb2MsIF9PST4oCgljb25zdCBfU2Fm ZV9pdGVyYXRvcjxfRGVxdWVfaXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBj b25zdCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+JiwK CWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIGNv bnN0IF9UcCYsIGNvbnN0IF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBf QWxsb2M+ID4mLCBfT0kpKTogTmV3LgoJKG1vdmVfYmFja3dhcmQ8X1RwLCBf QWxsb2MsIF9PST4oCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVxdWVfaXRl cmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwKCV9fZGVidWc6OmRlcXVlPF9UcCwg X0FsbG9jPiA+JiwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9EZXF1ZV9pdGVy YXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVxdWU8X1RwLCBf QWxsb2M+ID4mLCBfT0kpKTogTmV3LgoJKG1vdmVfYmFja3dhcmQ8X1RwLCBf QWxsb2M+KAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0RlcXVlX2l0ZXJhdG9y PF9UcCwgY29uc3QgX1RwJiwgY29uc3QgX1RwKj4sCglfX2RlYnVnOjpkZXF1 ZTxfVHAsIF9BbGxvYz4gPiYsCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVx dWVfaXRlcmF0b3I8X1RwLCBjb25zdCBfVHAmLCBjb25zdCBfVHAqPiwKCV9f ZGVidWc6OmRlcXVlPF9UcCwgX0FsbG9jPiA+JiwKCWNvbnN0IF9TYWZlX2l0 ZXJhdG9yPF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19k ZWJ1Zzo6ZGVxdWU8X1RwLCBfQWxsb2M+ID4mKSk6IE5ldy4KCShtb3ZlX2Jh Y2t3YXJkPF9UcCwgX0FsbG9jPigKCWNvbnN0IF9TYWZlX2l0ZXJhdG9yPF9E ZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6ZGVx dWU8X1RwLCBfQWxsb2M+ID4mLAoJY29uc3QgX1NhZmVfaXRlcmF0b3I8X0Rl cXVlX2l0ZXJhdG9yPF9UcCwgX1RwJiwgX1RwKj4sCglfX2RlYnVnOjpkZXF1 ZTxfVHAsIF9BbGxvYz4gPiYsCgljb25zdCBfU2FmZV9pdGVyYXRvcjxfRGVx dWVfaXRlcmF0b3I8X1RwLCBfVHAmLCBfVHAqPiwKCV9fZGVidWc6OmRlcXVl PF9UcCwgX0FsbG9jPiA+JikpOiBOZXcuCgkobW92ZV9iYWNrd2FyZDxfSUks IF9UcCwgX0FsbG9jPihfSUksIF9JSSwKCWNvbnN0IF9TYWZlX2l0ZXJhdG9y PF9EZXF1ZV9pdGVyYXRvcjxfVHAsIF9UcCYsIF9UcCo+LAoJX19kZWJ1Zzo6 ZGVxdWU8X1RwLCBfQWxsb2M+ID4mKSk6IE5ldy4KCSogdGVzdHN1aXRlLzI1 X2FsZ29yaXRobXMvY29weS9kZXF1ZV9pdGVyYXRvcnMvMTFfbmVnLmNjOiBO ZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL2NvcHkvZGVxdWVfaXRl cmF0b3JzLzEyX25lZy5jYzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxnb3Jp dGhtcy9jb3B5L2RlcXVlX2l0ZXJhdG9ycy8yLmNjOiBOZXcuCgkqIHRlc3Rz dWl0ZS8yNV9hbGdvcml0aG1zL2NvcHkvZGVxdWVfaXRlcmF0b3JzLzIxX25l Zy5jYzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9jb3B5L2Rl cXVlX2l0ZXJhdG9ycy8yMl9uZWcuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1 X2FsZ29yaXRobXMvY29weS9kZXF1ZV9pdGVyYXRvcnMvMzEuY2M6IE5ldy4K CSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvY29weS9kZXF1ZV9pdGVyYXRv cnMvMzIuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvY29w eS9kZXF1ZV9pdGVyYXRvcnMvMzMuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1 X2FsZ29yaXRobXMvY29weS9kZXF1ZV9pdGVyYXRvcnMvNDEuY2M6IE5ldy4K CSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvY29weS9kZXF1ZV9pdGVyYXRv cnMvNDIuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvY29w eS9kZXF1ZV9pdGVyYXRvcnMvNDMuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1 X2FsZ29yaXRobXMvY29weS9kZXF1ZV9pdGVyYXRvcnMvNTFfbmVnLmNjOiBO ZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL2NvcHkvZGVxdWVfaXRl cmF0b3JzLzYxX25lZy5jYzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxnb3Jp dGhtcy9jb3B5L2RlcXVlX2l0ZXJhdG9ycy83MV9uZWcuY2M6IE5ldy4KCSog dGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvY29weS9kZXF1ZV9pdGVyYXRvcnMv NzJfbmVnLmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL2Nv cHlfYmFja3dhcmQvZGVxdWVfaXRlcmF0b3JzLzExX25lZy5jYzogTmV3LgoJ KiB0ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9jb3B5X2JhY2t3YXJkL2RlcXVl X2l0ZXJhdG9ycy8xMl9uZWcuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1X2Fs Z29yaXRobXMvY29weV9iYWNrd2FyZC9kZXF1ZV9pdGVyYXRvcnMvMi5jYzog TmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9jb3B5X2JhY2t3YXJk L2RlcXVlX2l0ZXJhdG9ycy8yMV9uZWcuY2M6IE5ldy4KCSogdGVzdHN1aXRl LzI1X2FsZ29yaXRobXMvY29weV9iYWNrd2FyZC9kZXF1ZV9pdGVyYXRvcnMv MjJfbmVnLmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL2Vx dWFsL2RlcXVlX2l0ZXJhdG9ycy8xLmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8y NV9hbGdvcml0aG1zL2VxdWFsL2RlcXVlX2l0ZXJhdG9ycy8xMF9uZWcuY2M6 IE5ldy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvZXF1YWwvZGVxdWVf aXRlcmF0b3JzLzExX25lZy5jYzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxn b3JpdGhtcy9lcXVhbC9kZXF1ZV9pdGVyYXRvcnMvMTJfbmVnLmNjOiBOZXcu CgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL2VxdWFsL2RlcXVlX2l0ZXJh dG9ycy8xM19uZWcuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRo bXMvZXF1YWwvZGVxdWVfaXRlcmF0b3JzLzE0X25lZy5jYzogTmV3LgoJKiB0 ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9lcXVhbC9kZXF1ZV9pdGVyYXRvcnMv MTVfbmVnLmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL2Vx dWFsL2RlcXVlX2l0ZXJhdG9ycy8xNl9uZWcuY2M6IE5ldy4KCSogdGVzdHN1 aXRlLzI1X2FsZ29yaXRobXMvZXF1YWwvZGVxdWVfaXRlcmF0b3JzLzFfbmVn LmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL2VxdWFsL2Rl cXVlX2l0ZXJhdG9ycy8yX25lZy5jYzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVf YWxnb3JpdGhtcy9lcXVhbC9kZXF1ZV9pdGVyYXRvcnMvM19uZWcuY2M6IE5l dy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvZXF1YWwvZGVxdWVfaXRl cmF0b3JzLzRfbmVnLmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0 aG1zL2VxdWFsL2RlcXVlX2l0ZXJhdG9ycy81X25lZy5jYzogTmV3LgoJKiB0 ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9lcXVhbC9kZXF1ZV9pdGVyYXRvcnMv Nl9uZWcuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvZXF1 YWwvZGVxdWVfaXRlcmF0b3JzLzdfbmVnLmNjOiBOZXcuCgkqIHRlc3RzdWl0 ZS8yNV9hbGdvcml0aG1zL2VxdWFsL2RlcXVlX2l0ZXJhdG9ycy84X25lZy5j YzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9lcXVhbC9kZXF1 ZV9pdGVyYXRvcnMvOV9uZWcuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1X2Fs Z29yaXRobXMvZmlsbC9kZXF1ZV9pdGVyYXRvcnMvMS5jYzogTmV3LgoJKiB0 ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9maWxsL2RlcXVlX2l0ZXJhdG9ycy8x X25lZy5jYzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9tb3Zl L2RlcXVlX2l0ZXJhdG9ycy8xMV9uZWcuY2M6IE5ldy4KCSogdGVzdHN1aXRl LzI1X2FsZ29yaXRobXMvbW92ZS9kZXF1ZV9pdGVyYXRvcnMvMTJfbmVnLmNj OiBOZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdvcml0aG1zL21vdmUvZGVxdWVf aXRlcmF0b3JzLzIuY2M6IE5ldy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRo bXMvbW92ZS9kZXF1ZV9pdGVyYXRvcnMvMjFfbmVnLmNjOiBOZXcuCgkqIHRl c3RzdWl0ZS8yNV9hbGdvcml0aG1zL21vdmUvZGVxdWVfaXRlcmF0b3JzLzIy X25lZy5jYzogTmV3LgoJKiB0ZXN0c3VpdGUvMjVfYWxnb3JpdGhtcy9tb3Zl X2JhY2t3YXJkL2RlcXVlX2l0ZXJhdG9ycy8xMV9uZWcuY2M6IE5ldy4KCSog dGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvbW92ZV9iYWNrd2FyZC9kZXF1ZV9p dGVyYXRvcnMvMTJfbmVnLmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8yNV9hbGdv cml0aG1zL21vdmVfYmFja3dhcmQvZGVxdWVfaXRlcmF0b3JzLzIuY2M6IE5l dy4KCSogdGVzdHN1aXRlLzI1X2FsZ29yaXRobXMvbW92ZV9iYWNrd2FyZC9k ZXF1ZV9pdGVyYXRvcnMvMjFfbmVnLmNjOiBOZXcuCgkqIHRlc3RzdWl0ZS8y NV9hbGdvcml0aG1zL21vdmVfYmFja3dhcmQvZGVxdWVfaXRlcmF0b3JzLzIy X25lZy5jYzogTmV3Lgo= --------------E687385E247E3C8470735181--