public void If_x_equals_y_then_y_equals_x(Rational x, Rational y)
{
Assert.True(x.Equals(y) == y.Equals(x));
Assert.True(x.Equals((object)y) == y.Equals((object)x));
Assert.True((x == y) == (y == x));
Assert.True((x != y) == (y != x));
}
public void Case6()
{
const long LIGHT_YEAR = 5878625373183;
Rational altairDistance = 17 * LIGHT_YEAR;
Rational epsilonIndiDistance = 12 * LIGHT_YEAR;
Rational ursaeMajoris47Distance = 46 * LIGHT_YEAR;
long tauCetiDistance = 12 * LIGHT_YEAR;
ulong procyon2Distance = 12 * LIGHT_YEAR;
object wolf424ABDistance = 14 * LIGHT_YEAR;
Console.WriteLine("Approx. equal distances from Epsilon Indi to:");
Console.WriteLine(" Altair: {0}",
epsilonIndiDistance.Equals(altairDistance));
Console.WriteLine(" Ursae Majoris 47: {0}",
epsilonIndiDistance.Equals(ursaeMajoris47Distance));
Console.WriteLine(" TauCeti: {0}",
epsilonIndiDistance.Equals(tauCetiDistance));
Console.WriteLine(" Procyon 2: {0}",
epsilonIndiDistance.Equals(procyon2Distance));
Console.WriteLine(" Wolf 424 AB: {0}",
epsilonIndiDistance.Equals(wolf424ABDistance));
// The example displays the following output:
// Approx. equal distances from Epsilon Indi to:
// Altair: False
// Ursae Majoris 47: False
// TauCeti: True
// Procyon 2: True
// Wolf 424 AB: False
}
static void Main(string[] args)
{
int a = 2;
int b = 7;
int c = 5;
int d = 10;
Rational x = new Rational(a, b);
Rational y = new Rational(c, d);
Rational z = c;
Console.WriteLine("x=" + x);
Console.WriteLine("y=" + y);
Console.WriteLine("z=" + z);
Console.WriteLine("x is equals z?" + x.Equals(z));
Console.WriteLine("x is equals x?" + x.Equals(x));
Console.WriteLine("x compared to z?" + x.CompareTo(z));
Console.WriteLine("x+y=" + (x + y));
Console.WriteLine("y-x=" + (y - x));
Console.WriteLine("x*y=" + (x * y));
Console.WriteLine("x/y=" + (x / y));
Console.WriteLine("-z=" + -z);
Console.ReadKey();
}
public void Rational_are_not_equal_if_different_values(Rational x, Rational y)
{
Assert.True(x != y);
Assert.False(x == y);
Assert.False(Equals(x, y));
Assert.False(x.Equals(y));
Assert.False(x.Equals((object)y));
Assert.NotEqual(0, x.CompareTo(y));
}
public void If_both_are_lte_then_they_are_equal(Rational x, Rational y)
{
if (x <= y && y <= x)
{
Assert.True(x.Equals(y));
Assert.True(x.Equals((object)y));
Assert.True(x == y);
Assert.False(x != y);
Assert.Equal(0, x.CompareTo(y));
}
}
public void Rational_are_equivalent_if_represent_the_same_value(Rational x, Rational y)
{
Assert.True(Equals(x, y));
Assert.True(x == y);
Assert.True(x >= y);
Assert.True(x <= y);
Assert.True(x.Equals(y));
Assert.True(x.Equals((object)y));
Assert.Equal(0, x.CompareTo(y));
Assert.Equal(x.GetHashCode(), y.GetHashCode());
}
public void Rational_is_equal_to_itself(Rational x)
{
var y = x;
Assert.True(Equals(x, y));
Assert.True(x == y);
Assert.True(x >= y);
Assert.True(x <= y);
Assert.True(x.Equals(y));
Assert.True(x.Equals((object)y));
Assert.Equal(0, x.CompareTo(y));
}
public void ShouldHandleFractionCorrectly()
{
var first = new Rational(1.0 / 1600);
var second = new Rational(1.0 / 1600, true);
Assert.False(first.Equals(second));
}
public void Fraction()
{
var first = new Rational(1.0 / 1600);
var second = new Rational(1.0 / 1600, true);
Assert.False(first.Equals(second));
}
public void ShouldReturnTrueWhenObjectIsEqual()
{
var first = new Rational(3, 2);
var second = new Rational(3, 2);
Assert.True(first.Equals((object)second));
}
public void ShouldReturnFalseWhenInstanceIsNotEqual()
{
var first = new Rational(3, 2);
var second = new Rational(2, 3);
Assert.False(first.Equals(second));
}
public void Test_Fraction()
{
Rational first = new Rational(1.0 / 1600);
Rational second = new Rational(1.0 / 1600, true);
Assert.IsFalse(first.Equals(second));
}
public void ShouldReturnFalseWhenObjectIsNotEqual()
{
var first = new Rational(3, 2);
var second = new Rational(2, 3);
Assert.False(first.Equals((object)second));
}
public void ShouldReturnTrueWhenInstanceIsEqual()
{
var first = new Rational(3, 2);
var second = new Rational(3, 2);
Assert.True(first.Equals(second));
}
protected override IDataItem TestFunc(IDataItem p1, IDataItem p2)
{
var u = p1.ToRational().Value;
var v = p2.ToInt64().Value;
var w = Rational.Equals(u, v) ? 1U : 0U;
return(new UInt32DataItem(w));
}
public void Rational_is_not_equal_to_another_object()
{
var x = new Rational(1, 1);
var y = (1, 1);
Assert.False(Equals(x, y));
Assert.False(x.Equals(y));
}
public void Case7()
{
// The statement:
// bool comp = Int64.MaxValue == Int32.MaxValue;
// produces compiler error CS0220: The operation overflows at compile time in checked mode.
// The alternative:
bool comp = Rational.Equals(Int64.MaxValue, Int32.MaxValue);
}
public void Equals3()
{
// arrange
var p = new Rational(4, 2);
var q = new Rational(3, 2);
// assert
Assert.False(p.Equals(q));
}
public void Equals1()
{
// arrange
var p = new Rational(4, 2);
const int q = 2;
// assert
Assert.True(p.Equals(q));
}
public void Equals2()
{
// arrange
var p = new Rational(4, 2);
const string q = "hello";
// assert
// ReSharper disable once SuspiciousTypeConversion.Global
Assert.False(p.Equals(q));
}
public void RationalNumber_Equals()
{
//Arrange
var first = new Rational(1, 2);
var second = new Rational(1, 2);
bool expectedResult = true;
//Act
bool result = first.Equals(second);
//Assert
Assert.AreEqual(expectedResult, result);
}
public void RationalNumber_Equals_false()
{
//Arrange
var smaller = new Rational(1, 2);
var bigger = new Rational(5, 7);
bool expectedResult = false;
//Act
bool result = smaller.Equals(bigger);
//Assert
Assert.AreEqual(expectedResult, result);
}
public void SimplifyRationalNumber_SimplifyNumber_GetSimplified()
{
//arrange
Rational expected = new Rational(3, 6);
Rational actual = new Rational(1, 2);
//act
expected.SimplifyRationalNumber();
//assert
Assert.AreEqual(expected, actual);
Assert.IsTrue(actual.Equals(expected));
}
public void Case1()
{
Rational rationalValue;
decimal decimalValue = 16.2m;
rationalValue = new Rational(decimalValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
rationalValue.GetType().Name, rationalValue,
decimalValue.GetType().Name, decimalValue,
rationalValue.Equals(decimalValue));
// The example displays the following output:
// Rational 16.2 = Decimal 16.2 : True
}
public void RationalObjectNotEqual()
{
// Arrange
var rat1 = new Rational(8, 6);
var rat2 = new Rational(8, 7);
// Act
var eq1 = rat1.Equals(rat2);
var eq2 = rat2.Equals(rat1);
// Assert
Assert.IsFalse(eq1);
Assert.IsFalse(eq2);
}
public void RationalObjectsEqualDR(int p1, int p2, int p3, int p4)
{
// Arrange
var rat1 = new Rational(p1, p2);
var rat2 = new Rational(p3, p4);
// Act
var eq1 = rat1.Equals(rat2);
var eq2 = rat2.Equals(rat1);
// Assert
Assert.IsTrue(eq1);
Assert.IsTrue(eq2);
}
static void Test_Narrow()
{
Action <string> testNarrow = (text) => {
string[] parts = text.Split(' ', StringSplitOptions.RemoveEmptyEntries);
Rational r = Rational.Parse(parts[0]);
Rational b = Rational.Parse(parts[1]);
Rational exp = Rational.Parse(parts[2]);
Rational res = NarrowUtils.MakeNarrow(r, b);
Debug.WriteLine("{0,4} / base {1,-4} -> {2,-4} {3}", r, b, res,
res.Equals(exp) ? "Ok" : ("Expected " + exp.ToString()));
};
testNarrow("3 2 3/2");
testNarrow("3 1/2 3/2");
testNarrow("5 6 5/6");
}
public void RationalEqualityTest()
{
Rational rational = new Rational(1, 2);
Rational equal = new Rational(2, 4);
Rational notEqual = new Rational(3, 1);
// operators
(rational == rational).ShouldBeTrue();
(rational == equal).ShouldBeTrue();
(rational == notEqual).ShouldBeFalse();
(rational != equal).ShouldBeFalse();
(rational != notEqual).ShouldBeTrue();
// equality with rational
rational.Equals(rational).ShouldBeTrue();
rational.Equals(equal).ShouldBeTrue();
rational.Equals(notEqual).ShouldBeFalse();
// equality with object
rational.Equals((Object)rational).ShouldBeTrue();
rational.Equals((Object)equal).ShouldBeTrue();
rational.Equals((Object)notEqual).ShouldBeFalse();
rational.Equals(null).ShouldBeFalse();
rational.Equals(new Object()).ShouldBeFalse();
Rational.Zero.Equals(new Object()).ShouldBeFalse();
Rational.Zero.Equals(0).ShouldBeTrue();
Rational.MinValue.Equals(Int64.MinValue).ShouldBeTrue();
Rational.MaxValue.Equals(Int64.MaxValue).ShouldBeTrue();
// extrema
Rational positiveInfinity = new Rational(10, 0);
positiveInfinity.Equals(Rational.PositiveInfinity).ShouldBeTrue();
Rational negativeInfinity = new Rational(-10, 0);
negativeInfinity.Equals(Rational.NegativeInfinity).ShouldBeTrue();
Rational.PositiveInfinity.Equals(Rational.PositiveInfinity).ShouldBeTrue();
Rational.NegativeInfinity.Equals(Rational.NegativeInfinity).ShouldBeTrue();
Rational.NaN.Equals(Rational.NaN).ShouldBeTrue();
}
static void Main(string[] args)
{
Rational r = new Rational(8, 7);
Rational r1 = new Rational(9, 0);
Rational r2 = new Rational(-3, 3);
Console.WriteLine(r2);
Console.WriteLine(r1);
Rational r3 = new Rational(1, 2);
Rational r4 = new Rational(1, 2);
Console.WriteLine(r3);
Console.WriteLine(r4);
Console.WriteLine(r3.GreaterThen(r4));
Console.WriteLine(r3.Equals(r4));
Console.WriteLine(r3 + r4);
Console.WriteLine(r3 - r4);
Console.WriteLine(r3 * r4);
}
public void Case6()
{
int[] integers = { Int32.MinValue, -10534, -189, 0, 17, 113439,
Int32.MaxValue };
Rational constructed, assigned;
foreach (int number in integers)
{
constructed = new Rational(number);
assigned = number;
Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
constructed.Equals(assigned));
}
// The example displays the following output:
// -2147483648 = -2147483648: True
// -10534 = -10534: True
// -189 = -189: True
// 0 = 0: True
// 17 = 17: True
// 113439 = 113439: True
// 2147483647 = 2147483647: True
}
public void Test_IEquatable()
{
Rational first = new Rational(3, 2);
Assert.IsFalse(first.Equals(null));
Assert.IsTrue(first.Equals(first));
Assert.IsTrue(first.Equals((object)first));
Rational second = new Rational(3, 2);
Assert.IsTrue(first == second);
Assert.IsTrue(first.Equals(second));
Assert.IsTrue(first.Equals((object)second));
second = new Rational(2, 3);
Assert.IsTrue(first != second);
Assert.IsFalse(first.Equals(second));
}
public void Test_Fraction()
{
Rational first = new Rational(1.0 / 1600);
Rational second = new Rational(1.0 / 1600, true);
Assert.IsFalse(first.Equals(second));
}
