Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 386 insertions, 0 deletions

diff --git a/src/boost/libs/regex/test/regress/test_deprecated.cpp b/src/boost/libs/regex/test/regress/test_deprecated.cpp
new file mode 100644
index 00000000..493c02b2
--- /dev/null
+++ b/src/boost/libs/regex/test/regress/test_deprecated.cpp
@@ -0,0 +1,386 @@
+/*
+ *
+ * Copyright (c) 2004
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         test_deprecated.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Tests for deprecated interfaces.
+  */
+
+#include "test.hpp"
+#include <boost/cregex.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(disable:4267)
+#endif
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+   using ::atoi;
+   using ::wcstol;
+}
+#endif
+
+int get_posix_compile_options(boost::regex_constants::syntax_option_type opts)
+{
+   using namespace boost;
+   int result = 0;
+   switch(opts & regbase::main_option_type)
+   {
+   case regbase::perl:
+      result = (opts & regbase::no_perl_ex) ? REG_EXTENDED : REG_PERL;
+      if(opts & (regbase::no_bk_refs|regbase::no_mod_m|regbase::mod_x|regbase::mod_s|regbase::no_mod_s|regbase::no_escape_in_lists|regbase::no_empty_expressions))
+         return -1;
+      break;
+   case regbase::basic:
+      result = REG_BASIC;
+      if(opts & (regbase::no_char_classes|regbase::no_intervals|regbase::bk_plus_qm|regbase::bk_vbar))
+         return -1;
+      if((opts & regbase::no_escape_in_lists) == 0)
+         return -1;
+      break;
+   default:
+      return -1;
+   }
+
+   if(opts & regbase::icase)
+      result |= REG_ICASE;
+   if(opts & regbase::nosubs)
+      result |= REG_NOSUB;
+   if(opts & regbase::newline_alt)
+      result |= REG_NEWLINE;
+   if((opts & regbase::collate) == 0)
+      result |= REG_NOCOLLATE;
+
+   return result;
+}
+
+int get_posix_match_flags(boost::regex_constants::match_flag_type f)
+{
+   int result = 0;
+   if(f & boost::regex_constants::match_not_bol)
+      result |= boost::REG_NOTBOL;
+   if(f & boost::regex_constants::match_not_eol)
+      result |= boost::REG_NOTEOL;
+   if(f & ~(boost::regex_constants::match_not_bol|boost::regex_constants::match_not_eol))
+      return -1;
+   return result;
+}
+
+void test_deprecated(const char&, const test_regex_search_tag&)
+{
+   const std::string& expression = test_info<char>::expression();
+   if(expression.find('\0') != std::string::npos)
+      return;
+   const std::string& search_text = test_info<char>::search_text();
+   if(search_text.find('\0') != std::string::npos)
+      return;
+   int posix_options = get_posix_compile_options(test_info<char>::syntax_options());
+   if(posix_options < 0)
+      return;
+   int posix_match_options = get_posix_match_flags(test_info<char>::match_options());
+   if(posix_match_options < 0)
+      return;
+   const int* results = test_info<char>::answer_table();
+
+   // OK try and compile the expression:
+   boost::regex_tA re;
+   if(boost::regcompA(&re, expression.c_str(), posix_options) != 0)
+   {
+      BOOST_REGEX_TEST_ERROR("Expression : \"" << expression.c_str() << "\" did not compile with the POSIX C API.", char);
+      return;
+   }
+   // try and find the first occurance:
+   static const unsigned max_subs = 100;
+   boost::regmatch_t matches[max_subs];
+   if(boost::regexecA(&re, search_text.c_str(), max_subs, matches, posix_match_options) == 0)
+   {
+      int i = 0;
+      while(results[2*i] != -2)
+      {
+         if((int)max_subs > i)
+         {
+            if(results[2*i] != matches[i].rm_so)
+            {
+               BOOST_REGEX_TEST_ERROR("Mismatch in start of subexpression " << i << " found with the POSIX C API.", char);
+            }
+            if(results[2*i+1] != matches[i].rm_eo)
+            {
+               BOOST_REGEX_TEST_ERROR("Mismatch in end of subexpression " << i << " found with the POSIX C API.", char);
+            }
+         }
+         ++i;
+      }
+   }
+   else
+   {
+      if(results[0] >= 0)
+      {
+         BOOST_REGEX_TEST_ERROR("Expression : \"" << expression.c_str() << "\" was not found with the POSIX C API.", char);
+      }
+   }
+   // clean up whatever:
+   boost::regfreeA(&re);
+
+   //
+   // now try the RegEx class:
+   //
+   if(test_info<char>::syntax_options() & ~boost::regex::icase)
+      return;
+#ifndef BOOST_NO_EXCEPTIONS
+   try
+#endif
+   {
+      boost::RegEx e(expression, (test_info<char>::syntax_options() & boost::regex::icase) != 0);
+      if(e.error_code())
+      {
+         BOOST_REGEX_TEST_ERROR("Expression did not compile when it should have done, error code = " << e.error_code(), char);
+      }
+      if(e.Search(search_text, test_info<char>::match_options()))
+      {
+         int i = 0;
+         while(results[i*2] != -2)
+         {
+            if(e.Matched(i))
+            {
+               if(results[2*i] != static_cast<int>(e.Position(i)))
+               {
+                  BOOST_REGEX_TEST_ERROR("Mismatch in start of subexpression " << i << " found with the RegEx class (found " << e.Position(i) << " expected " << results[2*i] << ").", char);
+               }
+               if(results[2*i+1] != static_cast<int>(e.Position(i) + e.Length(i)))
+               {
+                  BOOST_REGEX_TEST_ERROR("Mismatch in end of subexpression " << i << " found with the RegEx class (found " << e.Position(i) + e.Length(i) << " expected " << results[2*i+1] << ").", char);
+               }
+            }
+            else
+            {
+               if(results[2*i] >= 0)
+               {
+                  BOOST_REGEX_TEST_ERROR("Mismatch in start of subexpression " << i << " found with the RegEx class (found " << e.Position(i) << " expected " << results[2*i] << ").", char);
+               }
+               if(results[2*i+1] >= 0)
+               {
+                  BOOST_REGEX_TEST_ERROR("Mismatch in end of subexpression " << i << " found with the RegEx class (found " << e.Position(i) + e.Length(i) << " expected " << results[2*i+1] << ").", char);
+               }
+            }
+            ++i;
+         }
+      }
+      else
+      {
+         if(results[0] >= 0)
+         {
+            BOOST_REGEX_TEST_ERROR("Expression : \"" << expression.c_str() << "\" was not found with class RegEx.", char);
+         }
+      }
+   }
+#ifndef BOOST_NO_EXCEPTIONS
+   catch(const boost::bad_expression& r)
+   {
+      BOOST_REGEX_TEST_ERROR("Expression did not compile with RegEx class: " << r.what(), char);
+   }
+   catch(const std::runtime_error& r)
+   {
+      BOOST_REGEX_TEST_ERROR("Unexpected std::runtime_error : " << r.what(), char);
+   }
+   catch(const std::exception& r)
+   {
+      BOOST_REGEX_TEST_ERROR("Unexpected std::exception: " << r.what(), char);
+   }
+   catch(...)
+   {
+      BOOST_REGEX_TEST_ERROR("Unexpected exception of unknown type", char);
+   }
+#endif
+}
+
+void test_deprecated(const wchar_t&, const test_regex_search_tag&)
+{
+#ifndef BOOST_NO_WREGEX
+   const std::wstring& expression = test_info<wchar_t>::expression();
+   if(expression.find(L'\0') != std::wstring::npos)
+      return;
+   const std::wstring& search_text = test_info<wchar_t>::search_text();
+   if(search_text.find(L'\0') != std::wstring::npos)
+      return;
+   int posix_options = get_posix_compile_options(test_info<wchar_t>::syntax_options());
+   if(posix_options < 0)
+      return;
+   int posix_match_options = get_posix_match_flags(test_info<wchar_t>::match_options());
+   if(posix_match_options < 0)
+      return;
+   const int* results = test_info<wchar_t>::answer_table();
+
+   // OK try and compile the expression:
+   boost::regex_tW re;
+   if(boost::regcompW(&re, expression.c_str(), posix_options) != 0)
+   {
+      BOOST_REGEX_TEST_ERROR("Expression : \"" << expression.c_str() << "\" did not compile with the POSIX C API.", wchar_t);
+      return;
+   }
+   // try and find the first occurance:
+   static const unsigned max_subs = 100;
+   boost::regmatch_t matches[max_subs];
+   if(boost::regexecW(&re, search_text.c_str(), max_subs, matches, posix_match_options) == 0)
+   {
+      int i = 0;
+      while(results[2*i] != -2)
+      {
+         if((int)max_subs > i)
+         {
+            if(results[2*i] != matches[i].rm_so)
+            {
+               BOOST_REGEX_TEST_ERROR("Mismatch in start of subexpression " << i << " found with the POSIX C API.", wchar_t);
+            }
+            if(results[2*i+1] != matches[i].rm_eo)
+            {
+               BOOST_REGEX_TEST_ERROR("Mismatch in end of subexpression " << i << " found with the POSIX C API.", wchar_t);
+            }
+         }
+         ++i;
+      }
+   }
+   else
+   {
+      if(results[0] >= 0)
+      {
+         BOOST_REGEX_TEST_ERROR("Expression : \"" << expression.c_str() << "\" was not found with the POSIX C API.", wchar_t);
+      }
+   }
+   // clean up whatever:
+   boost::regfreeW(&re);
+#endif
+}
+
+void test_deprecated(const char&, const test_invalid_regex_tag&)
+{
+   const std::string& expression = test_info<char>::expression();
+   if(expression.find('\0') != std::string::npos)
+      return;
+   int posix_options = get_posix_compile_options(test_info<char>::syntax_options());
+   if(posix_options < 0)
+      return;
+
+   // OK try and compile the expression:
+   boost::regex_tA re;
+   int code = boost::regcompA(&re, expression.c_str(), posix_options);
+   if(code == 0)
+   {
+      boost::regfreeA(&re);
+      BOOST_REGEX_TEST_ERROR("Expression : \"" << expression.c_str() << "\" unexpectedly compiled with the POSIX C API.", char);
+   }
+   else
+   {
+      char buf[100];
+      int s = boost::regerrorA(code, &re, 0, 0);
+      if(s < 100)
+         s = boost::regerrorA(code, &re, buf, 100);
+      s = boost::regerrorA(code | boost::REG_ITOA, &re, 0, 0);
+      if(s < 100)
+      {
+         s = boost::regerrorA(code | boost::REG_ITOA, &re, buf, 100);
+         re.re_endp = buf;
+         s = boost::regerrorA(code | boost::REG_ATOI, &re, buf, 100);
+         if(s)
+         {
+            int code2 = std::atoi(buf);
+            if(code2 != code)
+            {
+               BOOST_REGEX_TEST_ERROR("Got a bad error code from regerrA with REG_ATOI set: ", char);
+            }
+         }
+      }
+   }
+   //
+   // now try the RegEx class:
+   //
+   if(test_info<char>::syntax_options() & ~boost::regex::icase)
+      return;
+   bool have_catch = false;
+#ifndef BOOST_NO_EXCEPTIONS
+   try
+#endif
+   {
+      boost::RegEx e(expression, (test_info<char>::syntax_options() & boost::regex::icase) != 0);
+      if(e.error_code())
+         have_catch = true;
+   }
+#ifndef BOOST_NO_EXCEPTIONS
+   catch(const boost::bad_expression&)
+   {
+      have_catch = true;
+   }
+   catch(const std::runtime_error& r)
+   {
+      have_catch = true;
+      BOOST_REGEX_TEST_ERROR("Expected a bad_expression exception, but a std::runtime_error instead: " << r.what(), char);
+   }
+   catch(const std::exception& r)
+   {
+      have_catch = true;
+      BOOST_REGEX_TEST_ERROR("Expected a bad_expression exception, but a std::exception instead: " << r.what(), char);
+   }
+   catch(...)
+   {
+      have_catch = true;
+      BOOST_REGEX_TEST_ERROR("Expected a bad_expression exception, but got an exception of unknown type instead", char);
+   }
+#endif
+   if(!have_catch)
+   {
+      // oops expected exception was not thrown:
+      BOOST_REGEX_TEST_ERROR("Expected an exception, but didn't find one.", char);
+   }
+}
+
+void test_deprecated(const wchar_t&, const test_invalid_regex_tag&)
+{
+#ifndef BOOST_NO_WREGEX
+   const std::wstring& expression = test_info<wchar_t>::expression();
+   if(expression.find(L'\0') != std::string::npos)
+      return;
+   int posix_options = get_posix_compile_options(test_info<wchar_t>::syntax_options());
+   if(posix_options < 0)
+      return;
+
+   // OK try and compile the expression:
+   boost::regex_tW re;
+   int code = boost::regcompW(&re, expression.c_str(), posix_options);
+   if(code == 0)
+   {
+      boost::regfreeW(&re);
+      BOOST_REGEX_TEST_ERROR("Expression : \"" << expression.c_str() << "\" unexpectedly compiled with the POSIX C API.", wchar_t);
+   }
+   else
+   {
+      wchar_t buf[100];
+      int s = boost::regerrorW(code, &re, 0, 0);
+      if(s < 100)
+         s = boost::regerrorW(code, &re, buf, 100);
+      s = boost::regerrorW(code | boost::REG_ITOA, &re, 0, 0);
+      if(s < 100)
+      {
+         s = boost::regerrorW(code | boost::REG_ITOA, &re, buf, 100);
+         re.re_endp = buf;
+         s = boost::regerrorW(code | boost::REG_ATOI, &re, buf, 100);
+         if(s)
+         {
+            long code2 = std::wcstol(buf, 0, 10);
+            if(code2 != code)
+            {
+               BOOST_REGEX_TEST_ERROR("Got a bad error code from regerrW with REG_ATOI set: ", char);
+            }
+         }
+      }
+   }
+#endif
+}