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;
}