Example #1
0
 unsafe public bool PosTest2()
 {
     bool retVal = true;
     try
     {
         byte* mem = stackalloc byte[1024];
         System.IntPtr ip = new IntPtr((void*)mem);
         if (System.IntPtr.Size == 4)
         {
             if (ip.GetHashCode() != (int)mem)
             {
                 TestLibrary.TestFramework.LogError("002", "expect IntPtr.GetHashCode() equals the address");
                 retVal = false;
             }
         }
         else if (System.IntPtr.Size == 8)
         {
             if (ip.GetHashCode() != ((int)mem ^ (int)((long)mem >> 32)))
             {
                 TestLibrary.TestFramework.LogError("002", "expect IntPtr.GetHashCode() equals the address xor halves");
                 retVal = false;
             }
         }
         else
         {
             TestLibrary.TestFramework.LogError("002", "Unexpected IntPtr.Size: " + System.IntPtr.Size);
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
         retVal = false;
     }
     return retVal;
 }
Example #2
0
 public bool PosTest1()
 {
     bool retVal = true;
     try
     {
         System.IntPtr ip = new IntPtr(0);
         if (ip.GetHashCode() != 0)
         {
             TestLibrary.TestFramework.LogError("001", "expect IntPtr(0).GetHashCode() == 0");
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("001", "Unexpected exception: " + e);
         retVal = false;
     }
     return retVal;
 }
 public virtual bool runTest()
   {
   Console.Error.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
   int iCountErrors = 0;
   int iCountTestcases = 0;
   String strLoc = "Loc_000oo";
   IntPtr ip1;
   Int32 iValue;
   try {
   strLoc = "Loc_743wg";
   iValue = 16;
   ip1 = new IntPtr(iValue);
   iCountTestcases++;
   if(ip1.GetHashCode() != iValue){
   iCountErrors++;
   Console.WriteLine("Err_865sg! Wrong value returned");
   }             
   strLoc = "Loc_87453sg";
   iValue = -25;
   ip1 = new IntPtr(iValue);
   iCountTestcases++;
   if(ip1.GetHashCode() != iValue){
   iCountErrors++;
   Console.WriteLine("Err_97356sg! Wrong value returned");
   }             
   strLoc = "Loc_87453sg";
   iValue = 0;
   ip1 = new IntPtr(iValue);
   iCountTestcases++;
   if(ip1.GetHashCode() != iValue){
   iCountErrors++;
   Console.WriteLine("Err_97sdg! Wrong value returned");
   }             
   strLoc = "Loc_87453sg";
   iValue = Int32.MaxValue;
   ip1 = new IntPtr(iValue);
   iCountTestcases++;
   if(ip1.GetHashCode() != iValue){
   iCountErrors++;
   Console.WriteLine("Err_97sdg! Wrong value returned");
   }             
   strLoc = "Loc_87453sg";
   iValue = Int32.MinValue;
   ip1 = new IntPtr(iValue);
   iCountTestcases++;
   if(ip1.GetHashCode() != iValue){
   iCountErrors++;
   Console.WriteLine("Err_97sdg! Wrong value returned");
   }             
   } catch (Exception exc_general ) {
   ++iCountErrors;
   Console.WriteLine(s_strTFAbbrev +" Error Err_8888yyy!  strLoc=="+ strLoc +", exc_general=="+exc_general);
   }
   if ( iCountErrors == 0 )
     {
     Console.Error.WriteLine( "paSs.   "+s_strTFPath +" "+s_strTFName+" ,iCountTestcases=="+iCountTestcases);
     return true;
     }
   else
     {
     Console.Error.WriteLine("FAiL!   "+s_strTFPath+" "+s_strTFName+" ,iCountErrors=="+iCountErrors+" , BugNums?: "+s_strActiveBugNums );
     return false;
     }
   }
Example #4
0
 public static void TestEquals(IntPtr ptr1, object obj, bool expected)
 {
     if (obj is IntPtr)
     {
         IntPtr ptr2 = (IntPtr)obj;
         Assert.Equal(expected, ptr1 == ptr2);
         Assert.Equal(!expected, ptr1 != ptr2);
         Assert.Equal(expected, ptr1.GetHashCode().Equals(ptr2.GetHashCode()));
     }
     Assert.Equal(expected, ptr1.Equals(obj));
     Assert.Equal(ptr1.GetHashCode(), ptr1.GetHashCode());
 }
Example #5
0
 public bool PosTest3()
 {
     bool retVal = true;
     try
     {
         int anyAddr = TestLibrary.Generator.GetInt32(-55);
         System.IntPtr ip = new IntPtr(anyAddr);
         if (ip.GetHashCode() != anyAddr )
         {
             TestLibrary.TestFramework.LogError("003", String.Format("expect IntPtr.GetHashCode() == {0}", anyAddr));
             retVal = false;
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("003", "Unexpected exception: " + e);
         retVal = false;
     }
     return retVal;
 }
Example #6
0
 public bool PosTest4()
 {
     bool retVal = true;
     try
     {
         long addressOne = 0x123456FFFFFFFFL;
         long addressTwo = 0x654321FFFFFFFFL;
         System.IntPtr ipOne = new IntPtr(addressOne);
         System.IntPtr ipTwo = new IntPtr(addressTwo);
         if (ipOne.GetHashCode() == ipTwo.GetHashCode())
         {
             TestLibrary.TestFramework.LogError("004", "expect different hashcodes.");
             retVal = false;
         }
     }
     catch (System.OverflowException ex)
     {
         if (System.IntPtr.Size == 4)
         {
             // ok, that's what it should be
             return retVal;
         }
         else
  	{
             TestLibrary.TestFramework.LogError("004", "IntPtr should not have thrown an OverflowException: " + ex.ToString());
             retVal = false;
  	}
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
         retVal = false;
     }
     return retVal;
 }
Example #7
0
    public static unsafe void TestBasics()
    {
        if (sizeof(void*) == 4)
        {
            // Skip IntPtr tests on 32-bit platforms
            return;
        }

        IntPtr p;
        int i;
        long l;

        int size = IntPtr.Size;
        Assert.Equal(size, sizeof(void*));

        TestPointer(IntPtr.Zero, 0);

        i = 42;
        TestPointer(new IntPtr(i), i);
        TestPointer((IntPtr)i, i);

        i = 42;
        TestPointer(new IntPtr(i), i);

        i = -1;
        TestPointer(new IntPtr(i), i);

        l = 0x0fffffffffffffff;
        TestPointer(new IntPtr(l), l);
        TestPointer((IntPtr)l, l);

        void* pv = new IntPtr(42).ToPointer();
        TestPointer(new IntPtr(pv), 42);
        TestPointer((IntPtr)pv, 42);

        p = IntPtr.Add(new IntPtr(42), 5);
        TestPointer(p, 42 + 5);

        // Add is spected NOT to generate an OverflowException
        p = IntPtr.Add(new IntPtr(0x7fffffffffffffff), 5);
        unchecked
        {
            TestPointer(p, (long)0x8000000000000004);
        }

        p = IntPtr.Subtract(new IntPtr(42), 5);
        TestPointer(p, 42 - 5);

        bool b;
        p = new IntPtr(42);
        b = p.Equals(null);
        Assert.False(b);
        b = p.Equals((object)42);
        Assert.False(b);
        b = p.Equals((object)(new IntPtr(42)));
        Assert.True(b);

        int h = p.GetHashCode();
        int h2 = p.GetHashCode();
        Assert.Equal(h, h2);

        p = new IntPtr(42);
        i = (int)p;
        Assert.Equal(i, 42);
        l = (long)p;
        Assert.Equal(l, 42);
        IntPtr p2;
        p2 = (IntPtr)i;
        Assert.Equal(p, p2);
        p2 = (IntPtr)l;
        Assert.Equal(p, p2);
        p2 = (IntPtr)(p.ToPointer());
        Assert.Equal(p, p2);
        p2 = new IntPtr(40) + 2;
        Assert.Equal(p, p2);
        p2 = new IntPtr(44) - 2;
        Assert.Equal(p, p2);

        p = new IntPtr(0x7fffffffffffffff);
        Assert.Throws<OverflowException>(() => { i = (int)p; });
    }
Example #8
0
 public static void TestGetHashCodeRespectAllBits()
 {
     var ptr1 = new IntPtr(0x123456FFFFFFFF);
     var ptr2 = new IntPtr(0x654321FFFFFFFF);
     Assert.NotEqual(ptr1.GetHashCode(), ptr2.GetHashCode());
 }