public void CompareTo_ObjectTestStruct_0()
{
object other = TestStruct;
var exp = 0;
var act = TestStruct.CompareTo(other);
Assert.AreEqual(exp, act);
}
public void CompareTo_Object_SameAsGuid(
byte[] correctBytes,
byte[] correctCompareToBytes,
int expectedResult)
{
Assert.Multiple(() =>
{
Assert.AreEqual(16, correctBytes.Length);
Assert.AreEqual(16, correctCompareToBytes.Length);
Assert.True(expectedResult == -1 || expectedResult == 0 || expectedResult == 1);
var uuid = new Uuid(correctBytes);
var compareToUuid = new Uuid(correctCompareToBytes);
var compareToUuidObject = (object)compareToUuid;
var guid = new Guid(correctBytes);
var compareToGuid = new Guid(correctCompareToBytes);
var compareToGuidObject = (object)compareToGuid;
var uuidCompareToResult = uuid.CompareTo(compareToUuidObject);
var guidCompareToResult = guid.CompareTo(compareToGuidObject);
Assert.AreEqual(guidCompareToResult, uuidCompareToResult);
Assert.AreEqual(expectedResult, guidCompareToResult);
Assert.AreEqual(expectedResult, uuidCompareToResult);
});
}
public void CompareToObjectNullShouldReturn1(byte[] correctBytes)
{
var uuid = new Uuid(correctBytes);
int compareResult = uuid.CompareTo(null);
Assert.AreEqual(1, compareResult);
}
public void CompareToObjectOtherTypeShouldThrows(byte[] correctBytes)
{
var uuid = new Uuid(correctBytes);
Assert.Throws <ArgumentException>(() =>
{
int _ = uuid.CompareTo(1337);
});
}
public void CompareToObjectCorrect(
byte[] correctBytes,
byte[] correctCompareToBytes,
int expectedResult)
{
var uuid = new Uuid(correctBytes);
var uuidToCompareAsObject = (object)new Uuid(correctCompareToBytes);
int compareResult = uuid.CompareTo(uuidToCompareAsObject);
Assert.AreEqual(expectedResult, compareResult);
}
public void CompareTo_Object_AnotherType_SameAsGuid(byte[] correctBytes)
{
Assert.Multiple(() =>
{
Assert.AreEqual(16, correctBytes.Length);
var uuid = new Uuid(correctBytes);
var guid = new Guid(correctBytes);
Assert.Throws <ArgumentException>(() => guid.CompareTo(42));
Assert.Throws <ArgumentException>(() => uuid.CompareTo(42));
});
}
public void CompareTo_Object_Null_SameAsGuid(byte[] correctBytes)
{
Assert.Multiple(() =>
{
Assert.AreEqual(16, correctBytes.Length);
var uuid = new Uuid(correctBytes);
var guid = new Guid(correctBytes);
Assert.AreEqual(1, guid.CompareTo(null));
Assert.AreEqual(1, uuid.CompareTo(null));
});
}
public void Compare_should_produce_same_results_for_Guid_and_Uuid()
{
// arrange
// special case for small difference in last bytes (07...8b and 08..8a)
var guid1 = Guid.ParseExact("00000000-0000-0000-0000-010000000002", "d");
var guid2 = Guid.ParseExact("00000000-0000-0000-0000-020000000001", "d");
var uuid1 = new Uuid(guid1);
var uuid2 = new Uuid(guid2);
// act + assert
Assert.That(uuid1.CompareTo(uuid2), Is.EqualTo(guid1.CompareTo(guid2)));
Assert.That(uuid2.CompareTo(uuid1), Is.EqualTo(guid2.CompareTo(guid1)));
TestEnvironment.IterateTwoPairs((pair1, pair2) =>
{
Assert.That(pair1.Uuid.CompareTo(pair1.Uuid), Is.EqualTo(pair1.Guid.CompareTo(pair1.Guid)));
var actual = pair1.Uuid.CompareTo(pair2.Uuid);
var expected = pair1.Guid.CompareTo(pair2.Guid);
Assert.That(actual, Is.EqualTo(expected));
});
}
public int uuid_CompareToSameValueObject(Uuid uuid, object sameValue)
{
return(uuid.CompareTo(sameValue));
}
public int uuid_CompareTo_T_DifferentValue(Uuid uuid, Uuid differentValue)
{
return(uuid.CompareTo(differentValue));
}
public int uuid_CompareTo_T_SameValue(Uuid uuid, Uuid sameValue)
{
return(uuid.CompareTo(sameValue));
}
public int uuid_CompareToDifferentValueObject(Uuid uuid, object differentValue)
{
return(uuid.CompareTo(differentValue));
}
public int CompareTo(COMIELowRightsElevationPolicy other)
{
return(Uuid.CompareTo(other.Uuid));
}
public int UuidDifferentCompare()
{
return(_uuid1.CompareTo(_uuid2) ^ _uuid2.CompareTo(_uuid3) ^ _uuid3.CompareTo(_uuid1));
}
public int UuidDifferentCompare()
{
return(_uuid1.CompareTo(_uuid2Object) ^ _uuid2.CompareTo(_uuid1Object));
}
