libs/regex/test/regress/test_deprecated.cpp
/*
*
* 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 occurrence:
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);
}
std::string to_narrow_string(std::wstring const& w)
{
return std::string(w.begin(), w.end());
}
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 : \"" << to_narrow_string(expression.c_str()) << "\" did not compile with the POSIX C API.", wchar_t);
return;
}
// try and find the first occurrence:
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 : \"" << to_narrow_string(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);
}
}
}
}
}
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 : \"" << to_narrow_string(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
}