static void test_plain_characters() { static char const plain_characters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()-_=+[{]}|;:\",<.>/?"; // 1. Setup pantheios::be::test::reset(); // 2. Create test data { for(size_t i = 0; STLSOFT_NUM_ELEMENTS(plain_characters) - 1 != i; ++i) { PAN_CHAR_T const ch = plain_characters[i]; pantheios::log_NOTICE(PSTR("{"), pantheios::stream_character(ch), PSTR("}")); }} // 3. Verification pantheios::be::test::Results results = pantheios::be::test::results(); XTESTS_TEST(!results.empty()); XTESTS_TEST_INTEGER_EQUAL(STLSOFT_NUM_ELEMENTS(plain_characters) - 1, results.size()); { for(size_t i = 0; STLSOFT_NUM_ELEMENTS(plain_characters) - 1 != i; ++i) { PAN_CHAR_T const ch = plain_characters[i]; PAN_CHAR_T sz[4] = { '{', ch, '}', '\0' }; XTESTS_TEST_STRING_EQUAL(sz, results[i].statement); }} }
static void test_1_01() { // 1. Setup const PAN_CHAR_T prefix[] = PSTR("thread: "); PAN_CHAR_T tid_[21 + STLSOFT_NUM_ELEMENTS(prefix)]; PAN_CHAR_T const* tid = stlsoft::integer_to_string(&tid_[0], STLSOFT_NUM_ELEMENTS(tid_), pan_get_tid_()); PAN_CHAR_T const* stmt = tid - (STLSOFT_NUM_ELEMENTS(prefix) - 1); #ifdef PANTHEIOS_USE_WIDE_STRINGS ::wcsncpy(const_cast<PAN_CHAR_T*>(stmt), prefix, (STLSOFT_NUM_ELEMENTS(prefix) - 1)); #else /* ? PANTHEIOS_USE_WIDE_STRINGS */ ::strncpy(const_cast<PAN_CHAR_T*>(stmt), prefix, (STLSOFT_NUM_ELEMENTS(prefix) - 1)); #endif /* PANTHEIOS_USE_WIDE_STRINGS */ pantheios::be::test::reset(); // 2. Create test data pantheios::log_NOTICE(pantheios::threadId); pantheios::log_NOTICE(prefix, pantheios::threadId); // 3. Verification pantheios::be::test::Results results = pantheios::be::test::results(); XTESTS_TEST(!results.empty()); XTESTS_TEST(2 == results.size()); XTESTS_TEST_STRING_EQUAL(tid, results[0].statement); XTESTS_TEST_STRING_EQUAL(stmt, results[1].statement); }
inline winini_bundle::string_type winini_bundle::operator [](char_type const *name) const throw(std::out_of_range) { static const char_type sentinel[] = FASTFORMAT_LITERAL_STRING("{5DDAADE5-5134-4734-ACB8-A6D0FA3BD0EA}-{D875F19B-8279-4c44-9517-F16366BC13E3}"); ::SetLastError(0); char_type result[1001]; DWORD dw = ::GetPrivateProfileString( m_iniSection.c_str() , name , sentinel , &result[0] , STLSOFT_NUM_ELEMENTS(result) , m_iniFileName.c_str()); if(dw == STLSOFT_NUM_ELEMENTS(sentinel) - 1) /* element not found */ { if(0 == string_type::traits_type::compare(sentinel, result, stlsoft::minimum(size_t(dw), STLSOFT_NUM_ELEMENTS(sentinel) - 1))) { throw std::out_of_range("section/key combination does not exist in the given INI file"); } } ::GetLastError(); return string_type(result, dw); }
static int main_(int /* argc */, char** /* argv */) { #ifdef FASTFORMAT_USE_WIDE_STRINGS #else /* ? FASTFORMAT_USE_WIDE_STRINGS */ char const* arg0 = "abcdefghi"; const char arg1[] = "jklmnopq"; std::string arg2 = "rstuvwxyz"; { char buff[30]; ff::sinks::c_string_sink sink(STLSOFT_NUM_ELEMENTS(buff), &buff[0]); ff::write(sink, arg0); STLSOFT_ASSERT(9u == sink.size()); ff::write(sink, arg1); STLSOFT_ASSERT(17u == sink.size()); ff::write(sink, arg2); STLSOFT_ASSERT(26u == sink.size()); STLSOFT_ASSERT(0 == ::strcmp("abcdefghijklmnopqrstuvwxyz", buff)); } try { char buff[20]; ff::sinks::c_string_sink sink(STLSOFT_NUM_ELEMENTS(buff), &buff[0]); ff::write(sink, arg0); STLSOFT_ASSERT(9u == sink.size()); ff::write(sink, arg1); STLSOFT_ASSERT(17u == sink.size()); ff::write(sink, arg2); // Teleport to ... STLSOFT_MESSAGE_ASSERT("should never get here", 0); } catch(std::out_of_range& /* x */) { // ... here! } #endif /* FASTFORMAT_USE_WIDE_STRINGS */ return EXIT_SUCCESS; }
char const* c_str_data_a(double d) { int n = ::snprintf(&s_realBuffer[0], STLSOFT_NUM_ELEMENTS(s_realBuffer) - 1, "%G", d); if(n < 0) { n = STLSOFT_NUM_ELEMENTS(s_realBuffer) - 1; } s_realBuffer[n] = '\0'; return s_realBuffer; }
char const* c_str_data_a(void const volatile* p) { int n = ::snprintf(&s_realBuffer[0], STLSOFT_NUM_ELEMENTS(s_realBuffer) - 1, "0x%p", p); if(n < 0) { n = STLSOFT_NUM_ELEMENTS(s_realBuffer) - 1; } s_realBuffer[n] = '\0'; return s_realBuffer; }
inline /* static */ DISPID object_helper:: internal_GetIDOfName( object const& o, LPCOLESTR methodName ) /* const */ { DISPID dispids[1] = { 0 }; HRESULT hr = internal_has_member(o, methodName, &dispids[0]); if(FAILED(hr)) { if(DISP_E_UNKNOWNNAME == hr) { #if 0 stlsoft::exception_string_creator creator(256u); creator .append("Unknown name: '") .append(methodName) .append('\'') ; throw invocation_exception(creator.c_str(), hr); #else /* ? 0 */ typedef winstl::system_traits<char> traits_t; static const char msg[] = "Unknown name: '"; winstl::w2a a(methodName); stlsoft::auto_buffer<char> buff(STLSOFT_NUM_ELEMENTS(msg) + a.size() + 1); traits_t::char_copy(&buff[0], msg, STLSOFT_NUM_ELEMENTS(msg) - 1); traits_t::char_copy(&buff[0] + (STLSOFT_NUM_ELEMENTS(msg) - 1), a, a.size()); buff[(STLSOFT_NUM_ELEMENTS(msg) - 1) + a.size()] = '\''; buff[(STLSOFT_NUM_ELEMENTS(msg) - 1) + a.size() + 1] = '\0'; STLSOFT_ASSERT(1 + ::strlen(buff.data()) == buff.size()); // Guard against changing "size()" for winstl::wide2multibyte throw invocation_exception(buff.data(), hr); #endif /* 0 */ } else { throw invocation_exception("GetIDsOfNames failed", hr); } } return dispids[0]; }
void thread_id_t::construct_() { pan_char_t sz[21]; // This is large enough for any number up to 64-bits pan_char_t const* num = stlsoft::integer_to_string(&sz[0], STLSOFT_NUM_ELEMENTS(sz), pantheios_getCurrentThreadId(), m_len); ::memcpy(&m_value[0], num, (m_len + 1) * sizeof(pan_char_t)); }
static void test_1_01() { { for(size_t i = 0; i != STLSOFT_NUM_ELEMENTS(s_severities); ++i) { const int severity = s_severities[i]; // 1. Setup pantheios::be::test::reset(); // 2. Create test data pantheios::pantheios_logprintf(severity, PSTR("abc")); // 3. Verification pantheios::be::test::Results results = pantheios::be::test::results(); if(!results.empty()) // Do test here, so will work with any back-end { XTESTS_TEST(1 == results.size()); PANTHEIOS_SEV_LEVELS_EQUAL(severity, results[0].severity); XTESTS_TEST_STRING_EQUAL(PSTR("abc"), results[0].statement); } }} }
static void test_1_04() { // 1. Setup pantheios::be::test::reset(); // 2. Create test data char const* argv[] = { "abc" , "def" , "ghi" , "jkl" }; pantheios::log_NOTICE(pantheios::args(STLSOFT_NUM_ELEMENTS(argv), argv)); // 3. Verification pantheios::be::test::Results results = pantheios::be::test::results(); XTESTS_TEST(!results.empty()); XTESTS_TEST(1 == results.size()); XTESTS_TEST_MULTIBYTE_STRING_EQUAL("abc, def, ghi, jkl", results[0].statement); }
static void test_1_18() { // 1. Setup pantheios::be::test::reset(); // 2. Create test data char const* argv[] = { "abc" , "def ghi" , "jkl" }; pantheios::log_NOTICE(pantheios::args(STLSOFT_NUM_ELEMENTS(argv), argv, pantheios::args::alwaysQuoteArgs, "|")); // 3. Verification pantheios::be::test::Results results = pantheios::be::test::results(); XTESTS_TEST(!results.empty()); XTESTS_TEST(1 == results.size()); XTESTS_TEST_MULTIBYTE_STRING_EQUAL("\"abc\"|\"def ghi\"|\"jkl\"", results[0].statement); }
STDMETHODIMP CMainDlg::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { if( dispIdMember < BASE_DIPSPID || dispIdMember > sPhoneJsFunc[STLSOFT_NUM_ELEMENTS(sPhoneJsFunc) - 1]._dispId ) { return E_NOTIMPL; } // 检查参数个数 if(pDispParams->cArgs != sPhoneJsFunc[dispIdMember - BASE_DIPSPID]._argc) { return E_INVALIDARG; } // 所有的参数都是字符串 for(UINT i = 0; i < pDispParams->cArgs; ++i) { if((pDispParams->rgvarg[i].vt & VT_BSTR) == 0) { return E_INVALIDARG; } } return (this->*(sPhoneJsFunc[dispIdMember - BASE_DIPSPID]._pFuncProc))(dispIdMember, pDispParams, pVarResult); }
static char const* xcontract_lookup_violation_type_string_(xContract_violation_type_t type, size_t* len) { XCONTRACT_TYPE_STR_DECL(xContract_unexpectedCondition , "unexpected condition" ); XCONTRACT_TYPE_STR_DECL(xContract_precondition_logic , "precondition (logic)" ); XCONTRACT_TYPE_STR_DECL(xContract_precondition_parameters , "precondition (parameters)" ); XCONTRACT_TYPE_STR_DECL(xContract_postcondition_returnValue , "postcondition (return value)" ); XCONTRACT_TYPE_STR_DECL(xContract_postcondition_logic , "postcondition (logic)" ); XCONTRACT_TYPE_STR_DECL(xContract_postcondition_parameters , "postcondition (parameters)" ); XCONTRACT_TYPE_STR_DECL(xContract_invariant_class , "class invariant" ); XCONTRACT_TYPE_STR_DECL(xContract_invariant_global , "global invariant" ); XCONTRACT_TYPE_STR_DECL(xContract_staticData , "static data" ); XCONTRACT_TYPE_STR_DECL(xContract_intermediateAssumption , "global invariant" ); static const xContract_type_string* s_strings[] = { XCONTRACT_TYPE_STR_ENTRY(xContract_unexpectedCondition), XCONTRACT_TYPE_STR_ENTRY(xContract_precondition_logic), XCONTRACT_TYPE_STR_ENTRY(xContract_precondition_parameters), XCONTRACT_TYPE_STR_ENTRY(xContract_postcondition_returnValue), XCONTRACT_TYPE_STR_ENTRY(xContract_postcondition_logic), XCONTRACT_TYPE_STR_ENTRY(xContract_postcondition_parameters), XCONTRACT_TYPE_STR_ENTRY(xContract_invariant_class), XCONTRACT_TYPE_STR_ENTRY(xContract_invariant_global), XCONTRACT_TYPE_STR_ENTRY(xContract_staticData), XCONTRACT_TYPE_STR_ENTRY(xContract_intermediateAssumption), }; return xContract_lookup_type_(type, s_strings, STLSOFT_NUM_ELEMENTS(s_strings), len); }
static void test_1_01() { PAN_CHAR_T hostname[1000]; const string_t hid = pan_get_hid_(); { for(size_t i = 0; i != STLSOFT_NUM_ELEMENTS(hostname); ++i) { ::memset(&hostname[0], 0, sizeof(hostname)); const size_t len = pantheios::getHostName(&hostname[0], i); if(len == i) { // The function did not have enough space to write in, so it // will return the length passed to it ... XTESTS_TEST_INTEGER_EQUAL(i, len); // ... and will not have written anything to the file XTESTS_TEST_STRING_EQUAL(PANTHEIOS_LITERAL_STRING(""), hostname); } else { // The function had enough space, so it will return the length // of the intended hostname ... XTESTS_TEST_INTEGER_EQUAL(hid.size(), len); // ... and will have written the hostname XTESTS_TEST_STRING_EQUAL(hid, hostname); } }} }
int be_fprintf_Context::rawLogEntry( int severity4 , int /* severityX */ , const pan_slice_t (&ar)[rawLogArrayDimension] , size_t /* cchTotal */ ) { PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_INTERNAL(severity4 >= 0, "severity must be >= 0"); PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_INTERNAL(severity4 < 16, "severity must be < 16"); // select the stream: stdout for debug/info/notice; stderr for everything else FILE* const stm = deduce_stm_(severity4); const PAN_CHAR_T fmt[] = PANTHEIOS_LITERAL_STRING("%.*s%.*s%.*s%.*s%.*s%.*s%.*s%.*s%.*s%.*s\n"); STLSOFT_STATIC_ASSERT(4 * rawLogArrayDimension + 2 == STLSOFT_NUM_ELEMENTS(fmt)); // fprintf the array of slices #define PAN_BE_GET_SLICE_4_PRINTF(x) int(x.len), x.ptr return pan_fprintf_(stm, fmt , PAN_BE_GET_SLICE_4_PRINTF(ar[0]) , PAN_BE_GET_SLICE_4_PRINTF(ar[1]) , PAN_BE_GET_SLICE_4_PRINTF(ar[2]) , PAN_BE_GET_SLICE_4_PRINTF(ar[3]) , PAN_BE_GET_SLICE_4_PRINTF(ar[4]) , PAN_BE_GET_SLICE_4_PRINTF(ar[5]) , PAN_BE_GET_SLICE_4_PRINTF(ar[6]) , PAN_BE_GET_SLICE_4_PRINTF(ar[7]) , PAN_BE_GET_SLICE_4_PRINTF(ar[8]) , PAN_BE_GET_SLICE_4_PRINTF(ar[9])); }
// TODO: This should go in a src/util/x/y.cpp file static char* pan_make_hostIdentity_(void) { pan_char_t szHostName[1 + MAX_COMPUTERNAME_LENGTH]; size_t cch = pantheios_getHostName(&szHostName[0], STLSOFT_NUM_ELEMENTS(szHostName)); switch(cch) { case 0: case STLSOFT_NUM_ELEMENTS(szHostName): return pantheios_util_strdup_nothrow_m("<localhost>"); default: #ifdef PANTHEIOS_USE_WIDE_STRINGS return pantheios_util_strdup_nothrow_m(stlsoft::w2m(szHostName)); #else /* ? PANTHEIOS_USE_WIDE_STRINGS */ return pantheios_util_strdup_nothrow_m(szHostName); #endif /* PANTHEIOS_USE_WIDE_STRINGS */ } }
void stream_insert(S& s, ACE_Time_Value const& t) { char s1[20]; ACE_TCHAR s2[24]; const long s = t.sec(); const long us = t.usec(); struct tm *const tm = ACE_OS::localtime(&static_cast<time_t const&>(s)); as_size_t len = ACE_OS::strftime(s1, STLSOFT_NUM_ELEMENTS(s1), "%Y-%m-%d %H:%M:%S", tm); ACESTL_ASSERT(len == 1 + STLSOFT_NUM_ELEMENTS(s1)); len = ACE_OS::snprintf(s2, STLSOFT_NUM_ELEMENTS(s2), ACE_TEXT("%s.%03ld"), ACE_TEXT_CHAR_TO_TCHAR(s1), us / 1000); ACESTL_ASSERT(len == 1 + STLSOFT_NUM_ELEMENTS(s2)); s.write(&s2[0], len); }
static void test_2_00() { char const enc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ="; unsigned char bytes[10]; B64_RC rc = B64_RC_OK; size_t n = b64_decode2(enc, STLSOFT_NUM_ELEMENTS(enc) - 1u, &bytes[0], sizeof(bytes), 0, NULL, &rc); XTESTS_TEST_INTEGER_EQUAL(0u, n); XTESTS_TEST_ENUM_EQUAL(B64_RC_INSUFFICIENT_BUFFER, rc); }
static void test_1_13() { recls_char_t result[2]; size_t cch = Recls_SqueezePath(RECLS_LITERAL("abc/def/ghi"), &result[0], STLSOFT_NUM_ELEMENTS(result) - 1); result[cch] = '\0'; XTESTS_TEST_INTEGER_EQUAL(1u, cch); XTESTS_TEST_STRING_EQUAL(RECLS_LITERAL("g"), result); }
inline ::stlsoft::basic_shim_string<C> c_str_ptr_(ACE_Time_Value const& t) { typedef C char_t; as_char_a_t s1[20]; char_t s2[24]; const long s = t.sec(); const long us = t.usec(); struct tm *const tm = ACE_OS::localtime(&static_cast<time_t const&>(s)); as_size_t len = ACE_OS::strftime(s1, STLSOFT_NUM_ELEMENTS(s1), "%Y-%m-%d %H:%M:%S", tm); ACESTL_ASSERT(1 + len == STLSOFT_NUM_ELEMENTS(s1)); len = invoke_ACE_OS_snprintf(s2, STLSOFT_NUM_ELEMENTS(s2), ACE_TEXT("%s.%03ld"), s1, us / 1000); ACESTL_ASSERT(1 + len == STLSOFT_NUM_ELEMENTS(s2)); return ::stlsoft::basic_shim_string<char_t>(&s2[0], len); }
static void test_1_08() { signed char bytes[] = { 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7 }; char result[1001]; XTESTS_TEST_INTEGER_EQUAL(20u, b64_encode(&bytes[0], sizeof(bytes), NULL, 0)); XTESTS_TEST_INTEGER_EQUAL(20u, b64_encode(&bytes[0], sizeof(bytes), &result[0], STLSOFT_NUM_ELEMENTS(result))); result[1000] = '\0'; XTESTS_TEST_MULTIBYTE_STRING_EQUAL_N("BwYFBAMCAQD//v38+/r5", result, 20u); }
static void test_1_06() { unsigned char bytes[] = { 255 }; char result[1001]; XTESTS_TEST_INTEGER_EQUAL(4u, b64_encode(&bytes[0], sizeof(bytes), NULL, 0)); XTESTS_TEST_INTEGER_EQUAL(4u, b64_encode(&bytes[0], sizeof(bytes), &result[0], STLSOFT_NUM_ELEMENTS(result))); result[1000] = '\0'; XTESTS_TEST_MULTIBYTE_STRING_EQUAL_N("/w==", result, 4u); }
static void test_1_1() { clasp_alias_t ALIASES[] = { CLASP_BIT_FLAG(NULL, "-f", 0x0001, ""), CLASP_BIT_FLAG(NULL, "-g", 0x0002, ""), CLASP_BIT_FLAG(NULL, "-h", 0x0004, ""), CLASP_BIT_FLAG(NULL, "-i", 0x0006, ""), CLASP_ALIAS_ARRAY_TERMINATOR }; char* argv[] = { "arg0", NULL }; int const argc = STLSOFT_NUM_ELEMENTS(argv) - 1; clasp_arguments_t const* args; int const cr = clasp_parseArguments(0, argc, argv, NULL, NULL, &args); if(0 != cr) { XTESTS_TEST_FAIL_WITH_QUALIFIER("failed to initialise CLASP", strerror(cr)); } else { int const flagsAll = clasp_checkAllFlags(args, ALIASES, NULL); int const flagsAny = clasp_checkAllMatchingFlags(args, ALIASES, ~(int)0, NULL); int const flags0001 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0001, NULL); int const flags0002 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0002, NULL); int const flags0003 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0003, NULL); int const flags0004 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0004, NULL); int const flags0005 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0005, NULL); int const flags0006 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0006, NULL); int const flags0007 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0007, NULL); int const flags0008 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0008, NULL); XTESTS_TEST_INTEGER_EQUAL(0x0000, flagsAll); XTESTS_TEST_INTEGER_EQUAL(0x0000, flagsAny); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0001); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0002); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0003); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0004); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0005); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0006); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0007); XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0008); clasp_releaseArguments(args); } }
ff_char_t const* ximpl_core::fastformat_impl_replacements_getHashes(void* token, size_t len) { FASTFORMAT_CONTRACT_ENFORCE_PRECONDITION_PARAMS_INTERNAL(NULL != token, "state pointer must be null"); FASTFORMAT_COVER_MARK_ENTRY(); replacements_context_t_* ctxt = static_cast<replacements_context_t_*>(token); FASTFORMAT_CONTRACT_ENFORCE_PRECONDITION_PARAMS_INTERNAL(len <= STLSOFT_NUM_ELEMENTS(ctxt->hashes), "too many hashes requested"); STLSOFT_SUPPRESS_UNUSED(len); return ctxt->hashes; }
inline ss_size_t format_thousands( C *dest , ss_size_t cchDest , C const *picture , I const &number , C fmtSep , C outputSep ) { C szRawNumber[21]; // 21 is large enough for any 64-bit number (signed or unsigned) C const* rawNumber = integer_to_string(szRawNumber, STLSOFT_NUM_ELEMENTS(szRawNumber), static_cast<unsigned int>(number)); STLSOFT_STATIC_ASSERT(sizeof(C) <= 8); return translate_thousands(dest, cchDest, picture, rawNumber, fmtSep, outputSep); }
int main() { try { // Make a blob with some arbitrary values pantheios::uint8_t bytes[20]; { for(size_t i = 0; i < STLSOFT_NUM_ELEMENTS(bytes); ++i) { //bytes[i] = static_cast<pantheios::uint8_t>((i << 8) | (i & 0x0f)); bytes[i] = static_cast<pantheios::uint8_t>(i); }} // Log the blob with default formatting; Output: // // "bytes: [AAECAwQFBgcICQoLDA0ODxAREhM=]" pantheios::log_NOTICE(PSTR("bytes: ["), pantheios::b64(bytes, sizeof(bytes)), PSTR("]")); // Log the blob with a maximum line length of 16; Output: // "bytes: [AAECAwQFBgcICQoL // DA0ODxAREhM=]" pantheios::log_NOTICE(PSTR("bytes: ["), pantheios::b64(bytes, sizeof(bytes), ::b64::B64_F_LINE_LEN_USE_PARAM, 16), PSTR("]")); return EXIT_SUCCESS; } catch(std::bad_alloc&) { pantheios::log(pantheios::alert, PSTR("out of memory")); } catch(std::exception& x) { pantheios::log_CRITICAL(PSTR("Exception: "), x); } catch(...) { pantheios::logputs(pantheios::emergency, PSTR("Unexpected unknown error")); } return EXIT_FAILURE; }
STDMETHODIMP CMainDlg::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) { if(cNames == 0 || rgszNames == NULL || rgszNames[0] == NULL || rgDispId == NULL) { return E_INVALIDARG; } for(int i = 0; i < STLSOFT_NUM_ELEMENTS(sPhoneJsFunc); ++i) { if(_wcsicmp(rgszNames[0], sPhoneJsFunc[i]._pFuncName) == 0) { *rgDispId = sPhoneJsFunc[i]._dispId; return S_OK; } } return E_INVALIDARG; }
static void test_1_04() { { for(size_t i = 0; i != STLSOFT_NUM_ELEMENTS(s_severities); ++i) { const int severity = s_severities[i]; // 1. Setup pantheios::be::test::reset(); // 2. Create test data pantheios::pantheios_logputs(severity, PSTR("abc")); pantheios::pantheios_logputs(severity, PSTR("def")); pantheios::pantheios_logputs(severity, PSTR("abcdefghijklmnopqrstuvwxyz")); pantheios::pantheios_logputs(severity, PSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")); // 3. Verification pantheios::be::test::Results results = pantheios::be::test::results(); if(!results.empty()) // Do test here, so will work with any back-end { XTESTS_TEST(4 == results.size()); PANTHEIOS_SEV_LEVELS_EQUAL(severity, results[0].severity); XTESTS_TEST_STRING_EQUAL(PSTR("abc"), results[0].statement); PANTHEIOS_SEV_LEVELS_EQUAL(severity, results[1].severity); XTESTS_TEST_STRING_EQUAL(PSTR("def"), results[1].statement); PANTHEIOS_SEV_LEVELS_EQUAL(severity, results[2].severity); XTESTS_TEST_STRING_EQUAL(PSTR("abcdefghijklmnopqrstuvwxyz"), results[2].statement); PANTHEIOS_SEV_LEVELS_EQUAL(severity, results[3].severity); XTESTS_TEST_STRING_EQUAL(PSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"), results[3].statement); } }} }
static int main_(int /* argc */, char** /*argv*/) { const double values[] = { 0.0 , -12.34 , +12.34 , -12345.12345 , +12345.12345 , -12.34e-5 , +12.34e+5 }; { for(size_t i = 0; i != STLSOFT_NUM_ELEMENTS(values); ++i) { puts(""); printf("%%f: [%f]\n", values[i]); printf("%%20f: [%20f]\n", values[i]); printf("%%20.8f: [%20.8f]\n", values[i]); printf("%%20.4f: [%20.4f]\n", values[i]); printf("%%15f: [%15f]\n", values[i]); printf("%%15.8f: [%15.8f]\n", values[i]); printf("%%15.4f: [%15.4f]\n", values[i]); printf("%%10f: [%10f]\n", values[i]); printf("%%10.8f: [%10.8f]\n", values[i]); printf("%%10.4f: [%10.4f]\n", values[i]); printf("%%6f: [%6f]\n", values[i]); printf("%%6.8f: [%6.8f]\n", values[i]); printf("%%6.4f: [%6.4f]\n", values[i]); printf("%%5f: [%5f]\n", values[i]); printf("%%5.8f: [%5.8f]\n", values[i]); printf("%%5.4f: [%5.4f]\n", values[i]); printf("%%.5f: [%.5f]\n", values[i]); }} // printf("[%-14.3f%-14.3f]\n", 12345.12345, 12345.12345); // => [12345.123 12345.123 ] { for(size_t i = 0; i != STLSOFT_NUM_ELEMENTS(values); ++i) { const double value = values[i]; // ff::real ff::writeln(std::cout, "ff::real"); ff::fmtln(std::cout, "[{0} {0}]", ff::real(value)); ff::fmtln(std::cout, "[{0} {0}]", ff::real(value, 14, 3)); ff::fmtln(std::cout, "[{0} {0}]", ff::real(value, -14, 3)); // ff::to_f ff::writeln(std::cout, "ff::to_f"); ff::fmtln(std::cout, "[{0} {0}]", ff::to_f(value)); ff::fmtln(std::cout, "[{0} {0}]", ff::to_f(value, 14, 3)); ff::fmtln(std::cout, "[{0} {0}]", ff::to_f(value, -14, 3)); // ff::to_g ff::writeln(std::cout, "ff::to_g"); ff::fmtln(std::cout, "[{0} {0}]", ff::to_g(value)); ff::fmtln(std::cout, "[{0} {0}]", ff::to_g(value, 14, 3)); ff::fmtln(std::cout, "[{0} {0}]", ff::to_g(value, -14, 3)); // ff::to_e ff::writeln(std::cout, "ff::to_e"); ff::fmtln(std::cout, "[{0} {0}]", ff::to_e(value)); ff::fmtln(std::cout, "[{0} {0}]", ff::to_e(value, 14, 3)); ff::fmtln(std::cout, "[{0} {0}]", ff::to_e(value, -14, 3)); ff::writeln(std::cout, ""); ff::writeln(std::cout, ""); }} return EXIT_SUCCESS; }
static int main_(int /* argc */, char** /* argv */) { { #if 1 FILE* file = stdout; ff::fmtln(file #else /* ? 0 */ ff::fmtln(ff::FILE_ref(stdout, ff::buffered) #endif /* 0 */ , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } { FILE* file = stdout; ff::fmt(file , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); puts(""); } { ff::fmt(ff::to_sink(stdout) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); puts(""); } try { FILE* file = stdin; ff::fmt(file , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); puts(""); } catch(ff::sink_output_exception& x) { FILE* file = stderr; ff::writeln(file, x); } #ifdef DO_OTHER_TYPE_TESTS # if 0 { FILE* sink = stdout; ff::fmt(ff::flushed(stdout) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); puts(""); } { ff::fmt(ff::flushed(std_cout) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); puts(""); } { std_string sink; ff::fmt(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } { stlsoft::auto_buffer<ff::ff_char_t, 1000> sink(0); ff::fmt(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } { ff::ff_char_t buff[1001]; ff::sinks::char_buffer_sink sink(STLSOFT_NUM_ELEMENTS(buff), buff); ff::fmt(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } { ff::ff_char_t buff[1001]; ff::sinks::c_string_sink sink(STLSOFT_NUM_ELEMENTS(buff), buff); ff::fmt(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } { ff::sinks::null_sink sink; ff::fmt(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } # if defined(WIN32) || \ defined(WIN64) { CComBSTR sink; ff::fmt(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } { CString sink; ff::fmt(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } { ff::sinks::OutputDebugString_sink sink; ff::fmtln(ff::flushed(sink) , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def")); } # endif # else { FILE* sink = stdout; ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); puts(""); } { ff::flush( ff::fmt( std_cout , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); puts(""); } { std_string sink; ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } # if 0 { stlsoft::auto_buffer<ff::ff_char_t, 1000> sink(0); ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } # endif /* 0 */ { ff::ff_char_t buff[1001]; ff::sinks::char_buffer_sink sink(STLSOFT_NUM_ELEMENTS(buff), buff); ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } { ff::ff_char_t buff[1001]; ff::sinks::c_string_sink sink(STLSOFT_NUM_ELEMENTS(buff), buff); ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } { ff::sinks::null_sink sink; ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } # if defined(WIN32) || \ defined(WIN64) { CComBSTR sink; ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } # ifdef USE_MFC { CString sink; ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } # endif { ff::sinks::OutputDebugString_sink sink; ff::flush( ff::fmt( sink , FF_STR("Param #1: {0}; param #2: {1}; param #1 again: {0}"), FF_STR("abc"), FF_STR("def") ) ); } # endif # endif #endif /* DO_OTHER_TYPE_TESTS */ return EXIT_SUCCESS; }