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);
}
Beispiel #3
0
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;
        }
Beispiel #7
0
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];
    }
Beispiel #8
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);
}
Beispiel #12
0
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);
}
Beispiel #13
0
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);
        }
    }}
}
Beispiel #15
0
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]));
}
Beispiel #16
0
// 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 */
    }
}
Beispiel #17
0
    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);
    }
Beispiel #18
0
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);
}
Beispiel #20
0
    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);
    }
Beispiel #21
0
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);
}
Beispiel #22
0
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);
    }
}
Beispiel #24
0
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;
}
Beispiel #27
0
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;
}
Beispiel #30
0
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;
}