datetime.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

            }
            PEGASUS_TEST_ASSERT(gotException);
        }

        // testing toMicroSeconds when object has wild cards

        CIMDateTime tms_cdt1("00000000000000.12****:000");
        Uint64 ms1 = tms_cdt1.toMicroSeconds();
        if (ms1 != 120000)
        {
            cout << "problem converting " << tms_cdt1.
                toString() << " to MicroSeconds" << endl;
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime tms_cdt2("00000101000000.1234**+000");
        Uint64 ms2 = tms_cdt2.toMicroSeconds();
        if (ms2 != 123400)
        {
            cout << "problem converting " << tms_cdt2.
                toString() << " to MicroSeconds" << endl;
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime tms_cdt3("000000000001**.******:000");
        Uint64 ms3 = tms_cdt3.toMicroSeconds();
        if (ms3 != 60000000)
        {
            cout << "problem converting " << tms_cdt3.
                toString() << " to MicroSeconds" << endl;
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime tms_cdt4("**************.******+000");
        Uint64 ms4 = tms_cdt4.toMicroSeconds();
        if (ms4 != PEGASUS_UINT64_LITERAL(0))
        {
            cout << "problem converting " << tms_cdt4.
                toString() << " to MicroSeconds" << endl;
            PEGASUS_TEST_ASSERT(false);
        }

        /* verifying CIMDateTime::operator= */


        CIMDateTime org_vCo1("**************.******+000");
        CIMDateTime se_vCo1("99931231230200.000000-127");
        org_vCo1 = se_vCo1;
        if (String::compare(org_vCo1.toString(), se_vCo1.toString()))
        {
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime org_vCo2("12340101010101.******+000");
        CIMDateTime se_vCo2("00001231230200.000000-127");
        org_vCo2 = se_vCo2;
        if (String::compare(org_vCo2.toString(), se_vCo2.toString()))
        {
            PEGASUS_TEST_ASSERT(false);
        }



        /* testing equals() */

        if (!org_vCo1.equal(se_vCo1))
        {
            PEGASUS_TEST_ASSERT(false);
        }


        if (!org_vCo2.equal(se_vCo2))
        {
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime teeq3("12340101010101.******+000");
        CIMDateTime teeq3_comp("12340101010101.123456+000");
        if (!teeq3.equal(teeq3_comp))
        {
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime teeq4("12340101010101.212345+000");
        CIMDateTime teeq4_comp("12340101010101.2*****+000");
        if (!teeq4.equal(teeq4_comp))
        {
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime teeq5("12340101010101.2*****+000");
        CIMDateTime teeq5_comp("12340101010101.2234**+000");
        if (!teeq5.equal(teeq5_comp))
        {
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime teeq6("12340101010101.2*****+000");
        CIMDateTime teeq6_comp("123401010101**.******+000");
        if (!teeq6.equal(teeq6_comp))
        {
            PEGASUS_TEST_ASSERT(false);
        }

        CIMDateTime teeq7("12340101010101.2*****+000");
        CIMDateTime teeq7_comp("1234010101****.******+030");
        if (!teeq7.equal(teeq7_comp))
        {
            PEGASUS_TEST_ASSERT(false);
        }


        // 
        // Tests for getDifference.
        // 

        // One second difference
        {
            CIMDateTime dt1("20040520041400.000000+000");
            CIMDateTime dt2("20040520041401.000000+000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == 1000000);
        }

        // One day difference, with wildcards
        {
            CIMDateTime dt1("20040520041400.000000+050");
            CIMDateTime dt2("20040521041400.00****+050");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // UTC difference, with wildcards
        {
            CIMDateTime dt1("20040520041400.000***+000");
            CIMDateTime dt2("20040520041400.000000+120");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == -PEGASUS_SINT64_LITERAL(7200000000));
        }

        // Century non-leap year
        {
            CIMDateTime dt1("19000228041400.000000+000");
            CIMDateTime dt2("19000301041400.000000+000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // Century leap year
        {
            CIMDateTime dt1("20000229041400.000000+000");
            CIMDateTime dt2("20000301041400.000000+000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // Non-leap year
        {
            CIMDateTime dt1("20030228041400.000000+000");
            CIMDateTime dt2("20030301041400.000000+000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // Regular leap year
        {
            CIMDateTime dt1("20040229041400.000000+000");
            CIMDateTime dt2("20040301041400.000000+000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // Non-leap year
        {
            CIMDateTime dt1("20050228041400.000000+000");
            CIMDateTime dt2("20050301041400.000000+000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // UTC difference
        {
            CIMDateTime dt1("20020507170000.000000-300");
            CIMDateTime dt2("20020507170000.000000-480");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(10800000000));
        }

        // Negative UTC difference
        {
            CIMDateTime dt1("20020507170000.000000-480");
            CIMDateTime dt2("20020507170000.000000-300");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == -PEGASUS_SINT64_LITERAL(10800000000));
        }

        // Another UTC difference
        {
            CIMDateTime dt1("20020507170000.000000+330");
            CIMDateTime dt2("20020507170000.000000-480");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(48600000000));
        }

        // Another negative UTC difference
        {
            CIMDateTime dt1("20020507170000.000000-480");
            CIMDateTime dt2("20020507170000.000000+330");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == -PEGASUS_SINT64_LITERAL(48600000000));
        }

        // Microseconds difference
        {
            CIMDateTime dt1("20020507170000.000000-300");
            CIMDateTime dt2("20020507170000.000003-480");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(10800000003));
        }

        // Microseconds difference
        {
            CIMDateTime dt1("20020507170000.000003-300");
            CIMDateTime dt2("20020507170000.000000-480");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(10799999997));
        }

        // One day difference a long time ago
        {
            CIMDateTime dt1("19011214000000.000000-000");
            CIMDateTime dt2("19011215000000.000000-000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // One day difference a long time into the future
        {
            CIMDateTime dt1("20370101000000.000000-000");
            CIMDateTime dt2("20370102000000.000000-000");
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == PEGASUS_SINT64_LITERAL(86400000000));
        }

        // One minute interval difference
        {
            CIMDateTime dt1("00000001010100.000000:000");
            CIMDateTime dt2("00000001010200.000000:000");
            PEGASUS_TEST_ASSERT(dt1.isInterval());
            PEGASUS_TEST_ASSERT(dt2.isInterval());
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff == 60000000);
        }

        // Largest interval difference
        {
            CIMDateTime dt1("00000000000000.000000:000");
            CIMDateTime dt2("99999999235959.999999:000");
            PEGASUS_TEST_ASSERT(dt1.isInterval());
            PEGASUS_TEST_ASSERT(dt2.isInterval());
            Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            PEGASUS_TEST_ASSERT(diff ==
                                PEGASUS_SINT64_LITERAL(8639999999999999999));
        }

        // Mismatched interval and timestamp
        {
            CIMDateTime dt1("00000001010100.000000:000");
            CIMDateTime dt2("20020507170000.000000-480");
            PEGASUS_TEST_ASSERT(dt1.isInterval());
            PEGASUS_TEST_ASSERT(!dt2.isInterval());
            Boolean gotException = false;
            try
            {
                Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            }
            catch(const InvalidDateTimeFormatException &)
            {
                gotException = true;
            }
            PEGASUS_TEST_ASSERT(gotException);
        }

        // Mismatched timestamp and interval
        {
            CIMDateTime dt1("20040229041400.000000+000");
            CIMDateTime dt2("99999999235959.999999:000");
            PEGASUS_TEST_ASSERT(!dt1.isInterval());
            PEGASUS_TEST_ASSERT(dt2.isInterval());
            Boolean gotException = false;
            try
            {
                Sint64 diff = CIMDateTime::getDifference(dt1, dt2);
            }
            catch(const InvalidDateTimeFormatException &)
            {
                gotException = true;
            }
            PEGASUS_TEST_ASSERT(gotException);
        }


        // 
        // Tests for getCurrentDateTime
        // 
        {
            CIMDateTime currentTime1;
            CIMDateTime currentTime2;
            Boolean gotException = false;

            try
            {
                currentTime1 = CIMDateTime::getCurrentDateTime();
                currentTime2 = CIMDateTime::getCurrentDateTime();
            }
            catch(...)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(!gotException);

            // The literal value is approximately February 1, 2006.
            PEGASUS_TEST_ASSERT(currentTime1.toMicroSeconds() >
                                PEGASUS_UINT64_LITERAL(63306000000000000));

            // We don't expect the two getCurrentDateTime calls to happen more
            // than a second apart.
            PEGASUS_TEST_ASSERT(CIMDateTime::
                                getDifference(currentTime1,
                                              currentTime2) <= 1000000);
        }


        /*********************************************************
                testing operators added in PEP 192
     ************************************************************/

        // testing for operator+

        Uint64 tfo_n = PEGASUS_UINT64_LITERAL(123456732445);
        Uint64 tfo_nA = PEGASUS_UINT64_LITERAL(6789143423);
        CIMDateTime tfo_nCDT(tfo_n, true);
        CIMDateTime tfo_nACDT(tfo_nA, true);
        Uint64 sum_n = tfo_n + tfo_nA;
        CIMDateTime sum_CDT(sum_n, true);
        CIMDateTime CDT_sum = tfo_nCDT + tfo_nACDT;
        if (String::compare(CDT_sum.toString(), sum_CDT.toString()))
        {
            PEGASUS_TEST_ASSERT(false);
        }


        Uint64 tfo_n2 = PEGASUS_UINT64_LITERAL(1235764732445);
        Uint64 tfo_nA2 = PEGASUS_UINT64_LITERAL(6789143423);
        CIMDateTime tfo_nCDT2(tfo_n2, false);
        CIMDateTime tfo_nACDT2(tfo_nA2, true);
        Uint64 sum_n2 = tfo_n2 + tfo_nA2;
        CIMDateTime sum_CDT2(sum_n2, false);
        CIMDateTime CDT_sum2 = tfo_nCDT2 + tfo_nACDT2;
        if (String::compare(CDT_sum2.toString(), sum_CDT2.toString()))
        {
            PEGASUS_TEST_ASSERT(false);
        }


        Uint64 tfo_n3 = PEGASUS_UINT64_LITERAL(123456732445134);
        Uint64 tfo_nA3 = PEGASUS_UINT64_LITERAL(678947563423);
        CIMDateTime tfo_nCDT3(tfo_n3, false);
        CIMDateTime tfo_nACDT3(tfo_nA3, true);
        Uint64 sum_n3 = tfo_n3 + tfo_nA3;
        CIMDateTime sum_CDT3(sum_n3, false);
        CIMDateTime CDT_sum3 = tfo_nCDT3 + tfo_nACDT3;
        if (String::compare(CDT_sum3.toString(), sum_CDT3.toString()))
        {
            PEGASUS_TEST_ASSERT(false);
        }


        Uint64 tfo_n4 = PEGASUS_UINT64_LITERAL(123456732445134);
        Uint64 tfo_nA4 = PEGASUS_UINT64_LITERAL(678947563423);
        CIMDateTime tfo_nCDT4(tfo_n4, false);
        CIMDateTime tfo_nACDT4(tfo_nA4, true);
        Uint64 sum_n4 = tfo_n4 + tfo_nA4;
        CIMDateTime sum_CDT4(sum_n4, false);
        CIMDateTime CDT_sum4 = tfo_nCDT4 + tfo_nACDT4;
        if (String::compare(CDT_sum4.toString(), sum_CDT4.toString()))
        {
            PEGASUS_TEST_ASSERT(false);
        }


        CIMDateTime tfo_n5("20040520041400.0*****+450");
        CIMDateTime tfo_nA5("000405200414**.******:000");
        Uint64 num_n5 = tfo_n5.toMicroSeconds();
        Uint64 num_nA5 = tfo_nA5.toMicroSeconds();
        Uint64 sum5 = num_n5 + num_nA5;
        CIMDateTime sum_cdt5(sum5, false);
        CIMDateTime cdt_sum5 = tfo_n5 + tfo_nA5;
        if (String::compare(sum_cdt5.toString(), sum_cdt5.toString()))
        {
            PEGASUS_TEST_ASSERT(false);
        }

/*******************************************************************************************/

        // testing operator+=


        CIMDateTime top_cdt0("000405200414**.******:000");
        CIMDateTime topA_cdt0("00000520041452.******:000");
        Uint64 top_num0 = top_cdt0.toMicroSeconds();
        Uint64 topA_num0 = topA_cdt0.toMicroSeconds();
        Uint64 tot_num0 = top_num0 + topA_num0;
        top_cdt0 += topA_cdt0;