/// <summary>
        /// Method returns "string_rep_not_available" when no string representation is available
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            if (fvalue == null)
            {
                return("null");
            }

            if (fvalue.GetType().Equals(typeof(string)))
            {
                return(SourceCodePrinting.toSourceCodeString((string)fvalue));
            }

            string fvalueToString = null;
            Type   fvalueType     = null;

            try
            {
                fvalueToString = fvalue.ToString();
                fvalueType     = fvalue.GetType();
            }
            catch (Exception)
            {
                return("not_printable_ToString_Crashed");
            }

            if (fvalueType.IsPrimitive)
            {
                if (fvalueType.Equals(typeof(bool)))
                {
                    return("(" + ftype.ToString() + ")" + (fvalueToString.ToLower()));
                }

                if (fvalueType.Equals(typeof(byte)))
                {
                    return("(" + ftype.ToString() + ")" + SourceCodePrinting.ToCodeString2((byte)fvalue));
                }

                if (fvalueType.Equals(typeof(short)))
                {
                    return("(" + ftype.ToString() + ")" + SourceCodePrinting.ToCodeString2((short)fvalue));
                }

                if (fvalueType.Equals(typeof(int)))
                {
                    return("(" + ftype.ToString() + ")" + SourceCodePrinting.ToCodeString2((int)fvalue));
                }

                if (fvalueType.Equals(typeof(long)))
                {
                    return("(" + ftype.ToString() + ")" + SourceCodePrinting.ToCodeString2((long)fvalue));
                }

                if (fvalueType.Equals(typeof(float)))
                {
                    return("(" + ftype.ToString() + ")" + SourceCodePrinting.ToCodeString2((float)fvalue));
                }

                if (fvalueType.Equals(typeof(double)))
                {
                    return("(" + ftype.ToString() + ")" + SourceCodePrinting.ToCodeString2((double)fvalue));
                }

                if (fvalueType.Equals(typeof(char)))
                {
                    return("\'" + fvalueToString + "\'");
                }

                else
                {
                    return("(" + ftype.ToString() + ") (" + fvalueToString + ")");
                }
            }

            if (ftype.BaseType.Equals(systemEnum))
            {
                return(SourceCodePrinting.ToCodeString(ftype) + "." + fvalueToString);
            }

            if (fvalueType.IsValueType)
            {
                //check to see if this is the default value

                bool vEqArray = false;
                try
                {
                    ValueType v = fvalue as ValueType;
                    vEqArray = v.Equals(Array.CreateInstance(ftype, 1).GetValue(0));
                }
                catch (Exception)
                {
                    // Let vEqArray stay false.
                }

                if (vEqArray)
                {
                    string tStr = "typeof(" + SourceCodePrinting.ToCodeString(ftype) + ")";
                    string s    = "(" + SourceCodePrinting.ToCodeString(ftype) + ")(System.Array.CreateInstance(" + tStr + ", 1)).GetValue(0)";
                    return(s);
                }
                else
                {
                    try
                    {
                        //just perform a typecast to be sure (e.g. 1.1 is not recognized as a float unless cast
                        return("(" + SourceCodePrinting.ToCodeString(ftype) + ")(" + fvalueToString + ")");
                    }
                    catch
                    {
                        //This operation raises an exception sometime
                        //Util.Warning("The default value of ValueType<" + ftype.Name + "> is not" + fvalue.ToString());

                        return("\"__randoop_string_rep_not_available_forType<" + ftype.Name + ">\"");
                    }
                }
            }

            //just plain unlucky in this case
            return("\"__randoop_string_rep_not_available_forType<" + ftype.Name + ">\"");
        }