Subversion Repositories openrisc_2011-10-31

//==========================================================================

//

//      cdl1.cxx

//

//      Basic testing of the CDL utility functions.                                                        

//

//==========================================================================

//####COPYRIGHTBEGIN####

//                                                                          

// ----------------------------------------------------------------------------

// Copyright (C) 1999, 2000 Red Hat, Inc.

//

// This file is part of the eCos host tools.

//

// This program is free software; you can redistribute it and/or modify it 

// under the terms of the GNU General Public License as published by the Free 

// Software Foundation; either version 2 of the License, or (at your option) 

// any later version.

// 

// This program is distributed in the hope that it will be useful, but WITHOUT 

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 

// more details.

// 

// You should have received a copy of the GNU General Public License along with

// this program; if not, write to the Free Software Foundation, Inc., 

// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

//

// ----------------------------------------------------------------------------

//                                                                          

//####COPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####                                             

//

// Author(s):           bartv

// Contributors:        bartv

// Date:                1999-01-06

// Description:         There are a number of utility functions in the

//                      Cdl class to handle data validation, various

//                      conversions, etc.

//

//####DESCRIPTIONEND####

//==========================================================================

#include <cdlconfig.h>

#include <cdl.hxx>

#include <cyg/infra/cyg_ass.h>

#include <cyg/infra/cyg_trac.h>

#include <cyg/infra/testcase.h>

#include <cstdlib>

#include <cmath>

static bool

test_is_valid_property_id(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_is_valid_property_id", "success %d");

    if (!Cdl::is_valid_property_id(CdlPropertyId_ActiveIf)) {

        CYG_TEST_FAIL("ActiveIf should be a valid property id");

        result = false;

    }

    if (!Cdl::is_valid_property_id(CdlPropertyId_DefaultValue)) {

        CYG_TEST_FAIL("DefaultValue should be a valid property id");

        result = false;

    }

    if (!Cdl::is_valid_property_id(CdlPropertyId_Wizard)) {

        CYG_TEST_FAIL("Wizard should be a valid property id");

        result = false;

    }

    if (Cdl::is_valid_property_id(CdlPropertyId_Unknown)) {

        CYG_TEST_FAIL("is_valid_property_id() accepted an invalid number");

        result = false;

    }

    // This test could give spurious negatives in the very long term

    union {

        int           x;

        CdlPropertyId id;

    } dummy;

    dummy.x = 1234;

    if (Cdl::is_valid_property_id(dummy.id)) {

        CYG_TEST_FAIL("is_valid_property_id() accepted an invalid number");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_is_valid_property_class(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_is_valid_property_class", "success %d");

    if (!Cdl::is_valid_property_class(CdlPropertyClass_Minimal)) {

        CYG_TEST_FAIL("Minimal should be a valid property class");

        result = false;

    }

    if (!Cdl::is_valid_property_class(CdlPropertyClass_TclCode)) {

        CYG_TEST_FAIL("TclCode should be a valid property class");

        result = false;

    }

    if (!Cdl::is_valid_property_class(CdlPropertyClass_GoalExpression)) {

        CYG_TEST_FAIL("GoalExpression should be a valid property class");

        result = false;

    }

    if (Cdl::is_valid_property_class(CdlPropertyClass_Unknown)) {

        CYG_TEST_FAIL("is_valid_property_class() accepted an invalid number");

        result = false;

    }

    // This test could give spurious negatives in the very long term

    union {

        int                     x;

        CdlPropertyClass        id;

    } dummy;

    dummy.x = 1234;

    if (Cdl::is_valid_property_class(dummy.id)) {

        CYG_TEST_FAIL("is_valid_property_class() accepted an invalid number");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_is_valid_object_type(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_is_valid_object_type", "success %d");

    if (!Cdl::is_valid_object_type(CdlObjectType_Package)) {

        CYG_TEST_FAIL("Package should be a valid object type");

        result = false;

    }

    if (!Cdl::is_valid_object_type(CdlObjectType_Component)) {

        CYG_TEST_FAIL("Component should be a valid object type");

        result = false;

    }

    if (!Cdl::is_valid_object_type(CdlObjectType_Option)) {

        CYG_TEST_FAIL("Option should be a valid object type");

        result = false;

    }

    if (Cdl::is_valid_object_type(CdlObjectType_Unknown)) {

        CYG_TEST_FAIL("is_valid_object_type() accepted an invalid number");

        result = false;

    }

    // This test could give spurious negatives in the very long term

    union {

        int             x;

        CdlObjectType   id;

    } dummy;

    dummy.x = 1234;

    if (Cdl::is_valid_object_type(dummy.id)) {

        CYG_TEST_FAIL("is_valid_object_type() accepted an invalid number");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_is_valid_option_flavor(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_is_valid_option_flavor", "success %d");

    if (!Cdl::is_valid_option_flavor(CdlOptionFlavor_Bool)) {

        CYG_TEST_FAIL("Bool should be a valid option flavor");

        result = false;

    }

    if (!Cdl::is_valid_option_flavor(CdlOptionFlavor_Enum)) {

        CYG_TEST_FAIL("Enum should be a valid option flavor");

        result = false;

    }

    if (!Cdl::is_valid_option_flavor(CdlOptionFlavor_Count)) {

        CYG_TEST_FAIL("Count should be a valid option flavor");

        result = false;

    }

    if (Cdl::is_valid_option_flavor(CdlOptionFlavor_Unknown)) {

        CYG_TEST_FAIL("is_valid_option_flavor() accepted an invalid number");

        result = false;

    }

    // This test could give spurious negatives in the very long term

    union {

        int             x;

        CdlOptionFlavor id;

    } dummy;

    dummy.x = 1234;

    if (Cdl::is_valid_option_flavor(dummy.id)) {

        CYG_TEST_FAIL("is_valid_option_flavor() accepted an invalid number");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_is_valid_value_source(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_is_valid_value_source", "success %d");

    if (!Cdl::is_valid_value_source(CdlValueSource_Default)) {

        CYG_TEST_FAIL("Default is a valid value source");

        result = false;

    }

    if (!Cdl::is_valid_value_source(CdlValueSource_User)) {

        CYG_TEST_FAIL("User is a valid value source");

        result = false;

    }

    if (!Cdl::is_valid_value_source(CdlValueSource_Wizard)) {

        CYG_TEST_FAIL("Wizard is a valid value source");

        result = false;

    }

    if (!Cdl::is_valid_value_source(CdlValueSource_Inferred)) {

        CYG_TEST_FAIL("Inferred is a valid value source");

        result = false;

    }

    if (Cdl::is_valid_value_source(CdlValueSource_Unknown)) {

        CYG_TEST_FAIL("is_valid_value_source() accepted an invalid number");

        result = false;

    }

    // This test could give spurious negatives in the very long term

    union {

        int             x;

        CdlValueSource  id;

    } dummy;

    dummy.x = 1234;

    if (Cdl::is_valid_value_source(dummy.id)) {

        CYG_TEST_FAIL("is_valid_value_source() accepted an invalid number");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_string_to_integer(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_string_to_integer", "success %d");

    // Note that there is no robust way of specifying 64 bit constants.

    // Some compilers will use a LL suffix, but not all. When a 64 bit

    // constant is needed this has to be achieved using arithmetic,

    // leaving the compiler to do the hard work.

    //

    // Compiler bogosity: VC++ does not appear the more normal way

    // of initializing an array of structures using nested braces.

    struct conversion_data {

        bool            ok;

        const char*     source;

        cdl_int         expected;

    } data[] = {

        {  true,          "0",            0 },

        {  true,          "1",            1 },

        {  true,         "-1",           -1  },

        {  true,        "0x0",            0  },

        {  true,        "0x1",            1  },

        {  true,         "01",            1  },

        {  true,       "1234",         1234  },

        {  true,      "-4567",        -4567  },

        {  true, "2147483647",   2147483647  },

        {  true,"-2147483648",  ((cdl_int) -2147483647) - 1  },

        {  true, "0x7fffffff",   2147483647  },

        {  true,"-0x80000000",  ((cdl_int) -2147483647) -1  },

        {  true, "0x12ABCDEF",    313249263  },

        {  true, "12345678987654321", ((cdl_int) 111111111) * ((cdl_int) 111111111) },

        { false,          "A",            0  },

        { false,         "0A",            0  },

        { false,      "1234*",            0  },

        { false,   "finished",            0  }

    };

    for (int i = 0; 0 != strcmp("finished", data[i].source); i++) {

        cdl_int     res;

        std::string source = std::string(data[i].source);

        if (data[i].ok) {

            if (!Cdl::string_to_integer(source, res)) {

                std::string msg = "the string \"" + source + "\" was not converted";

                CYG_TEST_FAIL(msg.c_str());

                result = false;

            } else if (res != data[i].expected) {

                std::string msg = "the string \"" + source + "\" was converted incorrectly";

                CYG_TEST_FAIL(msg.c_str());

                result = false;

            }

        } else {

            if (Cdl::string_to_integer(source, res)) {

                std::string msg = "the string \"" + source + "\" is invalid but was still converted";

                CYG_TEST_FAIL(msg.c_str());

                result = false;

            }

        }

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_integer_to_string(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_integer_to_string", "success %d");

    // Note that there is no robust way of specifying 64 bit constants.

    // Some compilers will use a LL suffix, but not all. When a 64 bit

    // constant is needed this has to be achieved using arithmetic,

    // leaving the compiler to do the hard work.

    //

    // Integer to string conversions cannot fail.

    //

    // Compiler bogosity: VC++ does not appear the more normal way

    // of initializing an array of structures using nested braces.

    struct conversion_data {

        cdl_int         source;

        const char*     expected;

    } data[] = {

        {                0,           "0"  },

        {                1,           "1"  },

        {               -1,          "-1"  },

        {               10,          "10"  },

        {             1234,        "1234"  },

        {          -456789,     "-456789"  },

        {       2147483647,  "2147483647"  },

        { ((cdl_int) 111111111) * ((cdl_int) 111111111), "12345678987654321"  },

        {      (cdl_int) 0, "finished"     }

    };

    for (int i = 0; 0 != strcmp("finished", data[i].expected); i++) {

        std::string res;

        if (!Cdl::integer_to_string(data[i].source, res)) {

            std::string msg = "the integer \"" + std::string(data[i].expected) + "\" was not converted";

            CYG_TEST_FAIL(msg.c_str());

            result = false;

        } else if (res != data[i].expected) {

            std::string msg = "the string \"" + std::string(data[i].expected) + "\" was converted incorrectly";

            CYG_TEST_FAIL(msg.c_str());

            result = false;

        }

    }

    // Just a few more tests. Try converting some sequences to a string and back

    // again.

    for (int j = 0; j < 4; j++) {

        cdl_int starting_values[] = { 1, 3, -1, -2 };

        cdl_int current_value     = starting_values[j];

        for (int k = 0; k < 60; k++) {

            current_value <<= 1;

            cdl_int     int_tmp;

            std::string str_tmp;

            if (!Cdl::integer_to_string(current_value, str_tmp)) {

                CYG_TEST_FAIL("unable to convert valid integer to string");

                result = false;

                break;

            }

            if (!Cdl::string_to_integer(str_tmp, int_tmp)) {

                CYG_TEST_FAIL("unable to convert string back to integer");

                result = false;

                break;

            }

            if (current_value != int_tmp) {

                CYG_TEST_FAIL("integer conversion to/from strings not idempotent");

                result = false;

                break;

            }

        }

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_string_to_bool(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_string_to_bool", "success %d");

    // Legal values for true  include 1 and "true".

    // Legal values for false include 0 and "false".

    // A random string should fail to convert.

    bool res;

    if (!Cdl::string_to_bool("1", res)) {

        CYG_TEST_FAIL("the string \"1\" was not converted");

        result = false;

    } else if (res != true) {

        CYG_TEST_FAIL("the string \"1\" did not convert to true");

        result = false;

    }

    if (!Cdl::string_to_bool("true", res)) {

        CYG_TEST_FAIL("the string \"true\" was not converted");

        result = false;

    } else if (res != true) {

        CYG_TEST_FAIL("the string \"true\" did not convert to true");

        result = false;

    }

    if (!Cdl::string_to_bool("0", res)) {

        CYG_TEST_FAIL("the string \"0\" was not converted");

        result = false;

    } else if (res != false) {

        CYG_TEST_FAIL("the string \"0\" did not convert to false");

        result = false;

    }

    if (!Cdl::string_to_bool("false", res)) {

        CYG_TEST_FAIL("the string \"false\" was not converted");

        result = false;

    } else if (res != false) {

        CYG_TEST_FAIL("the string \"false\" did not convert to false");

        result = false;

    }

    if (Cdl::string_to_bool("not a boolean string", res)) {

        CYG_TEST_FAIL("a spurious string was converted to a boolean");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

static bool

test_bool_to_string(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_bool_to_string", "success %d");

    std::string str;

    if (!Cdl::bool_to_string(true, str)) {

        CYG_TEST_FAIL("bool_to_string() failed for `true'");

        result = false;

    } else if ("1" != str) {

        CYG_TEST_FAIL("boolean value true translated incorrectly");

        result = false;

    }

    if (!Cdl::bool_to_string(false,str)) {

        CYG_TEST_FAIL("bool_to_string() failed for `true'");

        result = false;

    } else if ("0" != str) {

        CYG_TEST_FAIL("boolean value false translated incorrectly");

        result = false;

    }

    // There is no easy way to test failure conditions. The trick

    // of sticking a random number into a union will not work, there

    // are absolutely no guarantees about the internal implementation

    // of the bool data type in C++

    CYG_REPORT_RETVAL(result);

    return result;

}

// This test is not intended to be comprehensive. In particular it is

// not very easy to validate the results, issues like locales get in the way.

static bool

test_double_to_string(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_double_to_string", "success %d");

    std::string str;

    if (!Cdl::double_to_string(0.0, str)) {

        CYG_TEST_FAIL("double_to_string() failed for 0.0");

        result = false;

    } else if (('0' != str[0]) && (('-' != str[0]) && ('0' != str[1]))) {

        fprintf(stderr, "result of conversion is %s\n", str.c_str());

        CYG_TEST_FAIL("double_to_string() returned strange result for 0.0");

        result = false;

    }

    if (!Cdl::double_to_string(3.141592, str)) {

        CYG_TEST_FAIL("double_to_string() failed for pi");

        result = false;

    } else if (('3' != str[0]) || ('1' != str[2]) || ('4' != str[3]) || ('1' != str[4])) {

        CYG_TEST_FAIL("double_to_string() returned strange result for pi");

        result = false;

    }

    if (!Cdl::double_to_string(-1.23456789E15, str)) {

        CYG_TEST_FAIL("double_to_string() failed for large but legal value");

        result = false;

    } else if (('-' != str[0]) && ('1' != str[1]) && (10 >= str.size())) {

        CYG_TEST_FAIL("double_to_string() returned strange result for large but legal value");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

// This test is not intended to be comprehensive.

static bool

test_string_to_double(void)

{

    bool result = true;

    CYG_REPORT_FUNCNAMETYPE("test_string_to_double", "success %d");

    double val;

    if (!Cdl::string_to_double("0.0", val)) {

        CYG_TEST_FAIL("string_to_double() failed for 0.0");

        result = false;

    } else if (fabs(val) > 0.000001) {

        CYG_TEST_FAIL("string_to_double() produced strange result for 0.0");

        result = false;

    }

    if (!Cdl::string_to_double("3.141592", val)) {

        CYG_TEST_FAIL("string_to_double() failed for pi");

        result = false;

    } else if (fabs(val - 3.141592) > 0.000001) {

        CYG_TEST_FAIL("string_to_double() produced strange result for pi");

        result = false;

    }

    if (!Cdl::string_to_double("-1.23456789E15", val)) {

        CYG_TEST_FAIL("string_to_double() failed for large but legal value");

        result = false;

    } else if (fabs(val - -1.23456789E15) > 0.000001) {

        CYG_TEST_FAIL("string_to_double() produced strange result for large but legal value");

        result = false;

    }

    if (Cdl::string_to_double("random junk", val)) {

        CYG_TEST_FAIL("string_to_double() succeeded for junk data");

        result = false;

    }

    if (Cdl::string_to_double("1.23456789E1234", val)) {

        CYG_TEST_FAIL("string_to_double() succeeded for impossibly large value");

        result = false;

    }

    if (Cdl::string_to_double("1.0 and then some", val)) {

        CYG_TEST_FAIL("string_to_double() succeeded for number followed by junk");

        result = false;

    }

    CYG_REPORT_RETVAL(result);

    return result;

}

int

main(int argc, char** argv)

{

    CYG_REPORT_FUNCNAMETYPE("main", "result %d");

    if (test_is_valid_property_id()) {

        CYG_TEST_PASS("is_valid_property_id()");

    }

    if (test_is_valid_property_class()) {

        CYG_TEST_PASS("is_valid_property_class()");

    }

    if (test_is_valid_object_type()) {

        CYG_TEST_PASS("is_valid_object_type()");

    }

    if (test_is_valid_option_flavor()) {

        CYG_TEST_PASS("is_valid_option_flavor");

    }

    if (test_is_valid_value_source()) {

        CYG_TEST_PASS("is_valid_value_source");

    }

    if (test_string_to_integer()) {

        CYG_TEST_PASS("string_to_integer");

    }

    if (test_string_to_bool()) {

        CYG_TEST_PASS("string to bool");

    }

    if (test_integer_to_string()) {

        CYG_TEST_PASS("integer_to_string");

    }

    if (test_bool_to_string()) {

        CYG_TEST_PASS("bool_to_string");

    }

    if (test_string_to_double()) {

        CYG_TEST_PASS("string_to_double");

    }

    if (test_double_to_string()) {

        CYG_TEST_PASS("double_to_string");

    }

    CYG_REPORT_RETVAL(EXIT_SUCCESS);

    return EXIT_SUCCESS;

}