static int Main()
    {
        StringBuilderCapacity test = new StringBuilderCapacity();

        TestFramework.BeginTestCase("StringBuilder.Capacity");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
Beispiel #2
0
    static int Main()
    {
        EncodingGetBytes1 test = new EncodingGetBytes1();

        TestFramework.BeginTestCase("Encoding.GetBytes");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
Beispiel #3
0
    static int Main()
    {
        EnumIsDefined test = new EnumIsDefined();

        TestFramework.BeginTestCase("Enum.IsDefined(enumType,value)");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
    static int Main()
    {
        ValueTypeEquals2 test = new ValueTypeEquals2();

        TestFramework.BeginTestCase("ValueType.Equals(Object,Object)");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
    public static int Main(string[] args)
    {
        EnvironmentProcessorCount test = new EnvironmentProcessorCount();

        TestFramework.BeginScenario("Testing Environment.ProcessorCount");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
    static int Main()
    {
        CompareInfoIsSuffix test = new CompareInfoIsSuffix();

        TestFramework.BeginTestCase("CompareInfo.IsSuffix");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
Beispiel #7
0
    static int Main()
    {
        StringJoin test = new StringJoin();

        TestFramework.BeginTestCase("String.Join");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
Beispiel #8
0
    static int Main()
    {
        EnumToString test = new EnumToString();

        TestFramework.BeginTestCase("Enum.ToString");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
    public static int Main(string[] args)
    {
        WeakReferenceCtor test = new WeakReferenceCtor();

        TestFramework.BeginTestCase("Testing WeakReference.Ctor (2)");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return(100);
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return(0);
        }
    }
Beispiel #10
0
    static int Main()
    {
        CompareInfoCompare test = new CompareInfoCompare();

        TestFramework.BeginTestCase("CompareInfo.Compare");

        if (test.RunTests())
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("PASS");
            return 100;
        }
        else
        {
            TestFramework.EndTestCase();
            TestFramework.LogInformation("FAIL");
            return 0;
        }

    }
    public static int Main(string[] args)
    {
        bool          retVal = true;
        DirectoryInfo di     = GetCurrentDir();

        foreach (FileInfo fi in di.EnumerateFiles("*.cer"))
        {
            TestFramework.LogInformation("==== " + fi.Name + " ====");
            retVal = DoValidate(fi) && retVal;
        }

        if (retVal)
        {
            TestFramework.LogInformation("SUCCESS!");
            return(100);
        }
        else
        {
            TestFramework.LogInformation("FAILED.");
            return(101);
        }
    }
Beispiel #12
0
    public bool PosTest(string input, byte[] expected, string id)
    {
        bool retVal = true;

        TestFramework.BeginScenario("\nPosTest " + id + ": FromBase64String");
        try
        {
            byte[] output = Convert.FromBase64String(input);
            if (!Utilities.CompareBytes(output, expected))
            {
                TestFramework.LogInformation("Input string: " + input);
                TestFramework.LogError("001", "Conversion not correct. Expect: " + Utilities.ByteArrayToString(expected) + ", Actual: " + Utilities.ByteArrayToString(output));
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e.ToString());
            retVal = false;
        }

        return(retVal);
    }
    static bool ValidateCertAgainstBaseline(IDictionary <string, string> certVals, X509Certificate cer)
    {
        bool retVal = true;
        long effectiveDateFound, expiryDateFound, effectiveDateBsl, expiryDateBsl;

        byte[] bytes;
        string str;
        int    hash;
        IntPtr handle;

        // now validate against the actual cert

        if (!certVals["HashString"].Equals(cer.GetCertHashString()))
        {
            TestFramework.LogError("001", "Expected hash string: " + certVals["HashString"] + ", found: " + cer.GetCertHashString());
            retVal = false;
        }

        // check the dates
        try
        {
            effectiveDateBsl   = Convert.ToInt64(certVals["EffectiveDateStringInTicks"]);
            effectiveDateFound = DateTime.Parse(cer.GetEffectiveDateString(), CultureInfo.InvariantCulture).ToUniversalTime().Ticks;
            expiryDateBsl      = Convert.ToInt64(certVals["ExpirationDateStringInTicks"]);
            expiryDateFound    = DateTime.Parse(cer.GetExpirationDateString(), CultureInfo.InvariantCulture).ToUniversalTime().Ticks;

            if (effectiveDateBsl != effectiveDateFound)
            {
                TestFramework.LogError("002", "Expected \"Valid From\": [" + (new DateTime(effectiveDateBsl, DateTimeKind.Utc)).ToString() + "], found: [" + cer.GetEffectiveDateString() + " nonUTC]");
                TestFramework.LogError("002", "                       ticks(" + effectiveDateBsl + ") found ticks(" + effectiveDateFound + ")");
                retVal = false;
            }

            if (expiryDateBsl != expiryDateFound)
            {
                TestFramework.LogError("003", "Expected \"Valid To\": [" + (new DateTime(expiryDateBsl)).ToString() + "], found: [" + cer.GetExpirationDateString() + " nonUTC]");
                TestFramework.LogError("003", "                       ticks(" + expiryDateBsl + ") found ticks(" + expiryDateFound + ")");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestFramework.LogError("103", "Unexpected exception: " + e);
            retVal = false;
        }

        TestFramework.LogInformation("  Validating field: Format");
        if (!certVals["Format"].Equals(cer.GetFormat()))
        {
            TestFramework.LogError("004", "Expected format: " + certVals["Format"] + ", found: " + cer.GetFormat());
            retVal = false;
        }

        TestFramework.LogInformation("  Validating field: Issuer");
        if (!certVals["Issuer"].Equals(cer.Issuer))
        {
            TestFramework.LogError("005", "Expected issuer: " + certVals["Issuer"] + ", found: " + cer.Issuer);
            retVal = false;
        }

        TestFramework.LogInformation("  Validating field: KeyAlgorithm");
        if (!certVals["KeyAlgorithm"].Equals(cer.GetKeyAlgorithm()))
        {
            TestFramework.LogError("006", "Expected key algorithm: " + certVals["KeyAlgorithm"] + ", found: " + cer.GetKeyAlgorithm());
            retVal = false;
        }

        TestFramework.LogInformation("  Validating field: KeyAlgorithmParameters");
        if (!certVals["KeyAlgorithmParameters"].Equals(cer.GetKeyAlgorithmParametersString()))
        {
            TestFramework.LogError("007", "Expected key alg parameters :" + certVals["KeyAlgorithmParameters"] + ", found :" +
                                   cer.GetKeyAlgorithmParametersString());
            retVal = false;
        }

        TestFramework.LogInformation("  Validating field: PublicKeyString");
        if (!certVals["PublicKeyString"].Equals(cer.GetPublicKeyString()))
        {
            TestFramework.LogError("008", "Expected public key: " + certVals["PublicKeyString"] + ", found: " +
                                   cer.GetPublicKeyString());
            retVal = false;
        }

        TestFramework.LogInformation("  Validating field: SerialNumberString");
        if (!certVals["SerialNumberString"].Equals(cer.GetSerialNumberString()))
        {
            TestFramework.LogError("009", "Expected serial number: " + certVals["SerialNumberString"] + ", found: " + cer.GetSerialNumberString());
            retVal = false;
        }

        TestFramework.LogInformation("  Validating field: Subject");
        if (!certVals["Subject"].Equals(cer.Subject))
        {
            TestFramework.LogError("010", "Expected subject: " + certVals["Subject"] + ", found: " + cer.Subject);
            retVal = false;
        }

        TestFramework.LogInformation("  Retrieving field: CertHash");
        bytes = cer.GetCertHash();

        TestFramework.LogInformation("  Retrieving field: HashCode");
        hash = cer.GetHashCode();

        TestFramework.LogInformation("  Retrieving field: RawCertHash");
        bytes = cer.GetRawCertData();

        TestFramework.LogInformation("  Retrieving field: RawCertDataString");
        str = cer.GetRawCertDataString();

        TestFramework.LogInformation("  Retrieving field: SerialNumber");
        bytes = cer.GetSerialNumber();

        TestFramework.LogInformation("  Retrieving field: ToString()");
        str = cer.ToString();

        TestFramework.LogInformation("  Retrieving field: ToString(true)");
        str = cer.ToString(true);

        TestFramework.LogInformation("  Retrieving field: Handle");
        handle = GetHandle(cer);

        TestFramework.LogInformation("  Testing: Equality with a string");
        if (cer.Equals(str))
        {
            TestFramework.LogError("110", "X509Certificate \"equals\" a string?");
            retVal = false;
        }

        TestFramework.LogInformation("  Testing: Equality with itself(1)");
        if (!cer.Equals((object)cer))
        {
            TestFramework.LogError("120", "X509Certificate does not equal itself");
            retVal = false;
        }

        TestFramework.LogInformation("  Testing: Equality with itself(2)");
        if (!cer.Equals(cer))
        {
            TestFramework.LogError("130", "X509Certificate does not equal itself");
            retVal = false;
        }

        return(retVal);
    }
Beispiel #14
0
 public static bool GenericCriticalMethod <T>()
 {
     TestFramework.LogInformation("\tSecurityCriticalMethod Method is invoked");
     return(true);
 }
Beispiel #15
0
 //Test methods
 public static bool GenericTransparentMethod <T>()
 {
     TestFramework.LogInformation("\tTransparentMethod is invoked");
     return(true);
 }
Beispiel #16
0
 public static bool SafeCriticalMethod()
 {
     TestFramework.LogInformation("\tSafeCriticalMethod Method is invoked");
     return(true);
 }
    static bool DoValidate(FileInfo fi)
    {
        bool         retVal;
        FileStream   fs;
        StreamReader fsr;
        IDictionary <string, string> certVals;
        X509Certificate cer;

        retVal   = true;
        fs       = File.Open(fi.FullName + ".bsl", FileMode.Open);
        fsr      = new StreamReader(fs);
        certVals = new Dictionary <string, string>();

        // open baseline file and retain expected values
        while (fsr.Peek() >= 0)
        {
            string[] lr = fsr.ReadLine().Split(new char[] { '|' });
            certVals.Add(lr[0], lr[1]);
        }
        fs.Close();

        // X509Certificate.CreateFromCertFile(String)
        TestFramework.LogInformation("-- importing certificate using X509Certificate.CreateFromCertFile()");
        cer = X509Certificate.CreateFromCertFile(fi.FullName);
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("011", "Certificate built with X509Certificate.CreateFromCertFile() failed");
        }

        // Import(String)
        TestFramework.LogInformation("-- importing certificate using .ctor() and Import(String)");
        cer = new X509Certificate();
        cer.Import(fi.FullName);
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("011", "Certificate built with default .ctor and Import(string) failed");
        }

        // Import(String,String,X509KeyStorageFlags)
        TestFramework.LogInformation("-- importing certificate using .ctor() and Import(String,String,X509KeyStorageFlags)");
        cer = new X509Certificate();
        foreach (X509KeyStorageFlags ksf in m_allKeyStorageFlags)
        {
            cer.Import(fi.FullName, "", ksf);
            if (!ValidateCertAgainstBaseline(certVals, cer))
            {
                retVal = false;
                TestFramework.LogError("012", "Certificate built with default .ctor and Import(string, string, X509StorageKeys) failed for " + ksf.ToString());
            }
        }

        // Import(byte[])
        cer = new X509Certificate();
        TestFramework.LogInformation("-- importing certificate using .ctor() and Import(byte[])");
        cer.Import(BytesFromFile(fi.FullName));
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("013", "Certificate built with default .ctor and Import(byte[]) failed");
        }

        // Import(byte[],String,X509KeyStorageFlags)
        TestFramework.LogInformation("-- importing certificate using .ctor() and Import(byte[],String,X509KeyStorageFlags)");
        cer = new X509Certificate();
        cer.Import(BytesFromFile(fi.FullName), "", X509KeyStorageFlags.DefaultKeySet);
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("014", "Certificate built with default .ctor and Import(byte[],string,X509StorageKeys) failed");
        }


        // second case: validate string ctor
        TestFramework.LogInformation("-- importing certificate using .ctor(String)");
        cer = new X509Certificate(fi.FullName);
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("015", "Certificate built with .ctor(String) failed");
        }


        // third case: validate string ctor with password
        TestFramework.LogInformation("-- importing certificate using .ctor(string,string) ");
        cer = new X509Certificate(fi.FullName, "");
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("016", "Certificate built with .ctor(String,String) failed");
        }


        // fourth case: validate string ctor with password and KeyStorageFlags
        TestFramework.LogInformation("-- importing certificate using .ctor() (String,String,X509KeyStorageFlags)");
        foreach (X509KeyStorageFlags ksf in m_allKeyStorageFlags)
        {
            cer = new X509Certificate(fi.FullName, "", ksf);
            if (!ValidateCertAgainstBaseline(certVals, cer))
            {
                retVal = false;
                TestFramework.LogError("017", "Certificate built with default .ctor and Import(string, string, X509StorageKeys) failed for " + ksf.ToString());
            }
        }

        // .ctor(IntPtr)
        TestFramework.LogInformation("-- importing certificate using .ctor(IntPtr) ");
        X509Certificate cerTmp = new X509Certificate(fi.FullName);

        cer = new X509Certificate(GetHandle(cerTmp));
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("016", "Certificate built with .ctor(IntPtr) failed");
        }
        GC.KeepAlive(cerTmp);

        // .ctor(X509Certificate)
        TestFramework.LogInformation("-- importing certificate using .ctor(X509Certificate) ");
        cer = new X509Certificate(new X509Certificate(fi.FullName));
        if (!ValidateCertAgainstBaseline(certVals, cer))
        {
            retVal = false;
            TestFramework.LogError("016", "Certificate built with .ctor(X509Certificate) failed");
        }

        return(retVal);
    }
Beispiel #18
0
        public static bool PosTest4()
        {
            ExplStruct p;
            bool       retval = false;

            TestFramework.BeginScenario("\n\nTest #4 (Roundtrip of a simple structre (Explicit layout) by value. Verify that values updated on unmanaged side reflect on managed side)");
            //direct pinvoke

            //cdecl
            try
            {
                p = new ExplStruct(DialogResult.OK, false);
                TestFramework.LogInformation(" Case 2: Direct p/invoke cdecl calling convention");
                p = DoCdeclSimpleExplStruct(p, ref retval);
                if (retval == false)
                {
                    TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side.");
                    return(false);
                }
                if ((p.type != DialogResult.Cancel) || (p.c != 3.142))
                {
                    Console.WriteLine("\nExpected values:\n SimpleStruct->a=2\nSimpleStruct->c=3.142\n");
                    Console.WriteLine("\nActual values:\n SimpleStruct->a=" + p.type + "\nSimpleStruct->c=" + p.c + "\n");
                    TestFramework.LogError("02", "PInvokeTests->PosTest4 : Returned values are different from expected values");
                    retval = false;
                }
            }
            catch (Exception e)
            {
                TestFramework.LogError("03", "Unexpected exception: " + e.ToString());
                retval = false;
            }

            //delegate pinvoke

            //cdecl
            try
            {
                p = new ExplStruct(DialogResult.OK, false);
                TestFramework.LogInformation(" Case 4: Direct p/invoke cdecl calling convention");

                CdeclSimpleExplStructDelegate std = GetFptrCdeclSimpleExplStruct(20);

                IntPtr st = std(p, ref retval);
                p = (ExplStruct)Marshal.PtrToStructure(st, typeof(ExplStruct));

                if (retval == false)
                {
                    TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side.");
                    return(false);
                }
                if ((p.type != DialogResult.Cancel) || (p.c != 3.142))
                {
                    Console.WriteLine("\nExpected values:\n SimpleStruct->a=2\nSimpleStruct->c=3.142\n");
                    Console.WriteLine("\nActual values:\n SimpleStruct->a=" + p.type + "\nSimpleStruct->c=" + p.c + "\n");
                    TestFramework.LogError("02", "PInvokeTests->PosTest4 : Returned values are different from expected values");
                    retval = false;
                }
            }
            catch (Exception e)
            {
                TestFramework.LogError("03", "Unexpected exception: " + e.ToString());
                retval = false;
            }
            return(retval);
        }
Beispiel #19
0
        public static bool PosTest3()
        {
            ExplStruct p;
            bool       retval = false;

            TestFramework.BeginScenario("\n\nTest #3 (Roundtrip of a simple structre (explicit layout) by reference. Verify that values updated on unmanaged side reflect on managed side)");
            //direct pinvoke

            //cdecl
            try
            {
                p = new ExplStruct(DialogResult.None, 10);
                TestFramework.LogInformation(" Case 2: Direct p/invoke cdecl calling convention");
                retval = DoCdeclSimpleExplStructByRef(ref p);

                if (retval == false)
                {
                    TestFramework.LogError("01", "PInvokeTests->PosTest3 : Unexpected error occured on unmanaged side");
                    return(false);
                }
                if ((p.type != DialogResult.OK) || (!p.b))
                {
                    Console.WriteLine("\nExpected values:\n SimpleStruct->type=1\nSimpleStruct->b=TRUE\n");
                    Console.WriteLine("\nActual values:\n SimpleStruct->type=" + p.type + "\nSimpleStruct->b=" + p.b);
                    TestFramework.LogError("02", "PInvokeTests->PosTest3 : Returned values are different from expected values");
                    retval = false;
                }
            }
            catch (Exception e)
            {
                TestFramework.LogError("03", "Unexpected exception: " + e.ToString());
                retval = false;
            }

            //Delegate pinvoke --- cdecl
            try
            {
                p = new ExplStruct(DialogResult.None, 10);
                TestFramework.LogInformation(" Case 4: Delegate p/invoke cdecl calling convention");
                CdeclSimpleExplStructByRefDelegate std = GetFptrCdeclSimpleExplStructByRef(18);

                retval = std(ref p);

                if (retval == false)
                {
                    TestFramework.LogError("01", "PInvokeTests->PosTest3 : Unexpected error occured on unmanaged side");
                    return(false);
                }
                if ((p.type != DialogResult.OK) || (!p.b))
                {
                    Console.WriteLine("\nExpected values:\n SimpleStruct->type=1\nSimpleStruct->b=TRUE\n");
                    Console.WriteLine("\nActual values:\n SimpleStruct->type=" + p.type + "\nSimpleStruct->b=" + p.b);
                    TestFramework.LogError("02", "PInvokeTests->PosTest3 : Returned values are different from expected values");
                    retval = false;
                }
            }
            catch (Exception e)
            {
                TestFramework.LogError("03", "Unexpected exception: " + e.ToString());
                retval = false;
            }


            return(retval);
        }
Beispiel #20
0
        public static bool PosTest2()
        {
            string s      = "Before";
            bool   retval = true;
            double d      = 3.142;
            Sstr   p      = new Sstr(100, false, s);

            TestFramework.BeginScenario("\n\nTest #2 (Roundtrip of a simple structre by value. Verify that values updated on unmanaged side reflect on managed side)");
            //direct pinvoke

            // //cdecl calling convention
            try
            {
                TestFramework.LogInformation(" Case 2: Direct p/invoke cdecl calling convention");
                Sstr_simple simple = new Sstr_simple(100, false, d);
                simple = DoCdeclSimpleStruct(simple, ref retval);

                if (retval == false)
                {
                    TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side.");
                    return(false);
                }
                if ((simple.a != 101) || (!simple.b) || (simple.c != 10.11))
                {
                    Console.WriteLine("\nExpected values:\n SimpleStruct->a=101\nSimpleStruct->b=TRUE\nSimpleStruct->c=10.11\n");
                    Console.WriteLine("\nActual values:\n SimpleStruct->a=" + simple.a + "\nSimpleStruct->b=" + simple.b + "\nSimpleStruct->c=" + simple.c + "\n");
                    TestFramework.LogError("02", "PInvokeTests->PosTest2 : Returned values are different from expected values");
                    retval = false;
                }
            }
            catch (Exception e)
            {
                TestFramework.LogError("03", "Unexpected exception: " + e.ToString());
                retval = false;
            }

            // //delegate pinvoke

            // //cdecl calling convention
            try
            {
                TestFramework.LogInformation(" Case 4: Delegate p/invoke cdecl calling convention");
                Sstr_simple simple            = new Sstr_simple(100, false, d);
                CdeclSimpleStructDelegate std = GetFptrCdeclSimpleStruct(16);

                IntPtr st = std(simple, ref retval);
                simple = (Sstr_simple)Marshal.PtrToStructure(st, typeof(Sstr_simple));


                if (retval == false)
                {
                    TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side.");
                    return(false);
                }
                if ((simple.a != 101) || (!simple.b) || (simple.c != 10.11))
                {
                    Console.WriteLine("\nExpected values:\n SimpleStruct->a=101\nSimpleStruct->b=TRUE\nSimpleStruct->c=10.11\n");
                    Console.WriteLine("\nActual values:\n SimpleStruct->a=" + simple.a + "\nSimpleStruct->b=" + simple.b + "\nSimpleStruct->c=" + simple.c + "\n");
                    TestFramework.LogError("02", "PInvokeTests->PosTest2 : Returned values are different from expected values");
                    retval = false;
                }
            }
            catch (Exception e)
            {
                TestFramework.LogError("03", "Unexpected exception: " + e.ToString());
                retval = false;
            }
            return(retval);
        }