Return to test_micxx.cpp CVS log

Up to [OMI] / omi / micxx / tests

Initial Import

/*
**==============================================================================
**
** Open Management Infrastructure (OMI)
**
** Copyright (c) Microsoft Corporation
** 
** Licensed under the Apache License, Version 2.0 (the "License"); you may not 
** use this file except in compliance with the License. You may obtain a copy 
** of the License at 
**
**     http://www.apache.org/licenses/LICENSE-2.0 
**
** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED 
** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
** MERCHANTABLITY OR NON-INFRINGEMENT. 
**
** See the Apache 2 License for the specific language governing permissions 
** and limitations under the License.
**
**==============================================================================
*/

#include <ut/ut.h>
#include <math.h>
#include <micxx/dinstance.h>
#include "Outer.h"

using namespace std;
using namespace mi;

static void setUp()
{
}

static void cleanup()
{
}

template<class T>
Array<T> MakeArray(const T& x, const T& y)
{
    Array<T> a;
    a.PushBack(x);
    a.PushBack(y);
    return a;
}

Array<String> MakeStrA(const String& x, const String& y)
{
    Array<String> a;
    a.PushBack(x);
    a.PushBack(y);
    return a;
}

static void Test1()
{
    DInstance di(T("Gadget"), DInstance::CLASS);
    const StringA COLORS = MakeArray<String>(T("Red"), T("Green"));
    const Uint32A NUMBERS = MakeArray<Uint32>(10, 20);

    UT_ASSERT(di.AddBoolean(T("True"), true));
    UT_ASSERT(di.AddBoolean(T("False"), false));
    UT_ASSERT(di.AddUint8(T("Uint8S"), 8));
    UT_ASSERT(di.AddString(T("Color"), T("Red")));
    UT_ASSERT(di.AddStringA(T("Colors"), COLORS));
    UT_ASSERT(di.AddUint32A(T("Numbers"), NUMBERS));

    {
        Boolean tmp;
        UT_ASSERT(di.GetBoolean(T("True"), tmp));
        UT_ASSERT(tmp);
    }
    {
        Boolean tmp;
        UT_ASSERT(di.GetBoolean(T("False"), tmp));
        UT_ASSERT(!tmp);
    }
    {
        Uint8 tmp;
        UT_ASSERT(di.GetUint8(T("Uint8S"), tmp));
        UT_ASSERT(tmp == 8);
    }
    {
        Uint32A tmp;
        UT_ASSERT(di.GetUint32A(T("Numbers"), tmp));
        UT_ASSERT(tmp.GetSize() == 2);
        UT_ASSERT(tmp[0] == NUMBERS[0]);
        UT_ASSERT(tmp[1] == NUMBERS[1]);
    }
    {
        StringA tmp;
        UT_ASSERT(di.GetStringA(T("Colors"), tmp));
        UT_ASSERT(tmp.GetSize() == COLORS.GetSize());
        UT_ASSERT(tmp.GetSize() == 2);
        UT_ASSERT(tmp[0] == COLORS[0]);
        UT_ASSERT(tmp[1] == COLORS[1]);
    }
    {
        String color;
        UT_ASSERT(di.SetString(T("Color"), T("Blue")));
    }


    // Person.Key=1
    {
        DInstance person(T("Person"), DInstance::ASSOCIATION);
        UT_ASSERT(person.AddUint32(T("Key"), 1, false, true));
        UT_ASSERT(person.AddString(T("First"), T("George")));
        UT_ASSERT(person.AddString(T("Last"), T("Washington")));

        Uint32 Key;
        bool isKey;
        bool isNull;
        UT_ASSERT(person.GetUint32(T("Key"), Key, isNull, isKey));
        UT_ASSERT(Key == 1);
        UT_ASSERT(isKey);
        UT_ASSERT(!isNull);

        String First;
        UT_ASSERT(person.GetString(T("First"), First));
        UT_ASSERT(First == T("George"));

        String Last;
        UT_ASSERT(person.GetString(T("Last"), Last));
        UT_ASSERT(Last == T("Washington"));
        UT_ASSERT(di.AddInstance(T("Person"), person));
    }

    DInstance d1(di);
    d1.AddString(T("Reason"), T("None"));
}

void Test2()
{
    DInstance d1;
    DInstance d2(d1);
    d2.AddUint32(T("P2"), 0);
}

void Test3()
{
    DInstance d1;
    d1.AddUint32(T("P2"), 0);
    d1.AddUint32(T("P1"), 0);

    DInstance d2(d1);
    DInstance d3(d2);
    DInstance d4;
    d4 = d3;
    d4 = d1;
    d4 = d2;
}

#if 0
template<class T>
Array<T> MakeArray(const T& x, Uint32 n)
{
    Array<T> a;
    for (Uint32 i = 0; i < n; i++)
    {
        a.PushBack(x);
    }

    return a;
}
#endif

bool Close(double x, double y)
{
    return fabs(x - y) <= 0.00001;
}

void CheckInnerInstance(const Inner_Class& inner)
{
    UT_ASSERT(inner.Key_value() == 32);
    UT_ASSERT(inner.Str_value() == T("Hello"));
}

template<class T>
struct CheckArray
{
    static bool func(const Array<T>& a, const T& x, const T& y)
    {
        return a.GetSize() == 2 && a[0] == x && a[1] == y;
    }
};

template<>
struct CheckArray<Real32>
{
    static bool func(const Array<Real32>& a, const Real32& x, const Real32& y)
    {
        return a.GetSize() == 2 && Close(a[0], x) && Close(a[1], y);
    }
};

template<>
struct CheckArray<Real64>
{
    static bool func(const Array<Real64>& a, const Real64& x, const Real64& y)
    {
        return a.GetSize() == 2 && Close(a[0], x) && Close(a[1], y);
    }
};

void CheckOuterInstance(const Outer_Class& x)
{
    UT_ASSERT(x.booleanScalar_value()); //  == true
    UT_ASSERT(x.uint8Scalar_value() == 8);
    UT_ASSERT(x.sint8Scalar_value() == -8);
    UT_ASSERT(x.uint16Scalar_value() == 16);
    UT_ASSERT(x.sint16Scalar_value() == -16);
    UT_ASSERT(x.uint32Scalar_value() == 32);
    UT_ASSERT(x.sint32Scalar_value() == -32);
    UT_ASSERT(x.uint64Scalar_value() == 64);
    UT_ASSERT(x.sint64Scalar_value() == -64);
    UT_ASSERT(Close(x.real32Scalar_value(), 32.32));
    UT_ASSERT(Close(x.real64Scalar_value(), 64.64));
    UT_ASSERT(x.char16Scalar_value() == 16);

    {
        Datetime datetimeScalar;
        datetimeScalar.Set(MI_T("20091231120030.123456+360"));
        UT_ASSERT(x.datetimeScalar_value() == datetimeScalar);
    }

    UT_ASSERT(x.stringScalar_value() == T("string"));

    CheckInnerInstance(x.instanceScalar_value());

    UT_ASSERT(CheckArray<Boolean>::func(x.booleanArray_value(), true, false));
    UT_ASSERT(CheckArray<Uint8>::func(x.uint8Array_value(), 8, 8));
    UT_ASSERT(CheckArray<Sint8>::func(x.sint8Array_value(), -8, -8));
    UT_ASSERT(CheckArray<Uint16>::func(x.uint16Array_value(), 16, 16));
    UT_ASSERT(CheckArray<Sint16>::func(x.sint16Array_value(), -16, -16));
    UT_ASSERT(CheckArray<Uint32>::func(x.uint32Array_value(), 32, 32));
    UT_ASSERT(CheckArray<Sint32>::func(x.sint32Array_value(), -32, -32));
    UT_ASSERT(CheckArray<Uint64>::func(x.uint64Array_value(), 64, 64));
    UT_ASSERT(CheckArray<Sint64>::func(x.sint64Array_value(), -64, -64));
    UT_ASSERT(CheckArray<Real32>::func(x.real32Array_value(), 32.32f, 32.32f));
    UT_ASSERT(CheckArray<Real64>::func(x.real64Array_value(), 64.64, 64.64));
    UT_ASSERT(CheckArray<Char16>::func(x.char16Array_value(), 16, 16));
    UT_ASSERT(CheckArray<String>::func(x.stringArray_value(), 
        String(T("string")), String(T("string"))));

    {
        Datetime dt;
        dt.Set(T("20091231120030.123456+360"));
        UT_ASSERT(CheckArray<Datetime>::func(x.datetimeArray_value(), dt, dt));
    }

    {
        UT_ASSERT(x.instanceArray_value().GetSize() == 2);
        CheckInnerInstance(x.instanceArray_value()[0]);
        CheckInnerInstance(x.instanceArray_value()[1]);
    }
}

void Test4()
{
    DInstance d0(T("Inner"), DInstance::CLASS);
    d0.AddUint32(T("Key"), 32);
    d0.AddString(T("Str"), T("Hello"));

    DInstance d1(T("Outer"), DInstance::CLASS);
    d1.AddBoolean(T("booleanScalar"), true);
    d1.AddUint8(T("uint8Scalar"), 8);
    d1.AddSint8(T("sint8Scalar"), -8);
    d1.AddUint16(T("uint16Scalar"), 16);
    d1.AddSint16(T("sint16Scalar"), -16);
    d1.AddUint32(T("uint32Scalar"), 32);
    d1.AddSint32(T("sint32Scalar"), -32);
    d1.AddUint64(T("uint64Scalar"), 64);
    d1.AddSint64(T("sint64Scalar"), -64);
    d1.AddReal32(T("real32Scalar"), 32.32f);
    d1.AddReal64(T("real64Scalar"), 64.64);
    d1.AddChar16(T("char16Scalar"), 16);
    Datetime datetimeScalar;
    datetimeScalar.Set(T("20091231120030.123456+360"));
    d1.AddDatetime(T("datetimeScalar"), datetimeScalar);
    d1.AddString(T("stringScalar"), T("string"));
    d1.AddInstance(T("instanceScalar"), d0);

    d1.AddBooleanA(T("booleanArray"), MakeArray(Boolean(true), Boolean(false)));
    d1.AddUint8A(T("uint8Array"), MakeArray(Uint8(8), Uint8(8)));
    d1.AddSint8A(T("sint8Array"), MakeArray(Sint8(-8), Sint8(-8)));
    d1.AddUint16A(T("uint16Array"), MakeArray(Uint16(16), Uint16(16)));
    d1.AddSint16A(T("sint16Array"), MakeArray(Sint16(-16), Sint16(-16)));
    d1.AddUint32A(T("uint32Array"), MakeArray(Uint32(32), Uint32(32)));
    d1.AddSint32A(T("sint32Array"), MakeArray(Sint32(-32), Sint32(-32)));
    d1.AddUint64A(T("uint64Array"), MakeArray(Uint64(64), Uint64(64)));
    d1.AddSint64A(T("sint64Array"), MakeArray(Sint64(-64), Sint64(-64)));
    d1.AddReal32A(T("real32Array"), MakeArray(Real32(32.32), Real32(32.32)));
    d1.AddReal64A(T("real64Array"), MakeArray(Real64(64.64), Real64(64.64)));
    d1.AddChar16A(T("char16Array"), MakeArray(Char16(16), Char16(16)));
    d1.AddDatetimeA(T("datetimeArray"), 
        MakeArray(datetimeScalar, datetimeScalar));
    d1.AddStringA(T("stringArray"), 
        MakeArray(String(T("string")), String(T("string"))));
#if 1
    d1.AddInstanceA(T("instanceArray"), MakeArray(d0, d0));
#endif

    Outer_Class outer;
    bool flag = DInstance::DynamicToStatic(d1, false, false, outer);
    UT_ASSERT(flag == true);
    CheckOuterInstance(outer);
}

void Test5()
{
    DInstance d0(T("Inner"), DInstance::CLASS);
    d0.AddUint32(T("Key"), 32);
    d0.AddString(T("Str"), T("Hello"));

    DInstance d1(T("Outer"), DInstance::CLASS);
    d1.AddString(T("booleanScalar"), T("true"));
    d1.AddString(T("uint8Scalar"), T("8"));
    d1.AddString(T("uint8Scalar"), T("8"));
    d1.AddString(T("sint8Scalar"), T("-8"));
    d1.AddString(T("uint16Scalar"), T("16"));
    d1.AddString(T("sint16Scalar"), T("-16"));
    d1.AddString(T("uint32Scalar"), T("32"));
    d1.AddString(T("sint32Scalar"), T("-32"));
    d1.AddString(T("uint64Scalar"), T("64"));
    d1.AddString(T("sint64Scalar"), T("-64"));
    d1.AddString(T("real32Scalar"), T("32.32"));
    d1.AddString(T("real64Scalar"), T("64.64"));
    d1.AddString(T("char16Scalar"), T("16"));
    d1.AddString(T("datetimeScalar"), T("20091231120030.123456+360"));
    d1.AddString(T("stringScalar"), T("string"));
    d1.AddInstance(T("instanceScalar"), d0);

    d1.AddStringA(T("booleanArray"), MakeStrA(T("true"), T("false")));

    d1.AddStringA(T("uint8Array"), MakeStrA(T("8"), T("8")));
    d1.AddStringA(T("sint8Array"), MakeStrA(T("-8"), T("-8")));

    d1.AddStringA(T("uint16Array"), MakeStrA(T("16"), T("16")));
    d1.AddStringA(T("sint16Array"), MakeStrA(T("-16"), T("-16")));

    d1.AddStringA(T("uint32Array"), MakeStrA(T("32"), T("32")));
    d1.AddStringA(T("sint32Array"), MakeStrA(T("-32"), T("-32")));

    d1.AddStringA(T("uint64Array"), MakeStrA(T("64"), T("64")));
    d1.AddStringA(T("sint64Array"), MakeStrA(T("-64"), T("-64")));

    d1.AddStringA(T("real32Array"), MakeStrA(T("32.32"), T("32.32")));
    d1.AddStringA(T("real64Array"), MakeStrA(T("64.64"), T("64.64")));

    d1.AddStringA(T("char16Array"), MakeStrA(T("16"), T("16")));

    d1.AddStringA(T("datetimeArray"), MakeStrA(T("20091231120030.123456+360"), 
        T("20091231120030.123456+360")));

    d1.AddStringA(T("stringArray"), 
        MakeArray(String(T("string")), String(T("string"))));
    d1.AddInstanceA(T("instanceArray"), MakeArray(d0, d0));

    Outer_Class outer;
    bool flag = DInstance::DynamicToStatic(d1, false, false, outer);
    UT_ASSERT(flag == true);

    CheckOuterInstance(outer);

    DInstance dinst2;
    flag = DInstance::StaticToDynamic(outer, false, dinst2);
    UT_ASSERT(flag == true);

    Outer_Class outer2;
    flag = DInstance::DynamicToStatic(dinst2, false, false, outer2);
    UT_ASSERT(flag == true);

    CheckOuterInstance(outer2);
}

static void RunTests()
{
    UT_TEST(Test1);
    UT_TEST(Test2);
    UT_TEST(Test3);
    UT_TEST(Test4);
    UT_TEST(Test5);
}

UT_ENTRY_POINT(RunTests);