public void ClearTest_GivenABlankBijective()
{
var bijective = new Bijective <object, object>();
IEnumerable <Tuple <object, object> > allBijections = null;
IEnumerable <Tuple <object, object> > allReverseBijections = null;
IEnumerable <object> allItemsLeft = null;
IEnumerable <object> allItemsRight = null;
try
{
bijective.Clear();
allBijections = bijective.GetAllBijections();
allReverseBijections = bijective.GetAllReverseBijections();
allItemsLeft = bijective.GetAllLeftElements();
allItemsRight = bijective.GetAllRightElements();
}
catch
{
Assert.Fail();
}
Assert.AreEqual(0, new List <Tuple <object, object> >(allBijections).Count);
Assert.AreEqual(0, new List <Tuple <object, object> >(allReverseBijections).Count);
Assert.AreEqual(0, new List <object>(allItemsLeft).Count);
Assert.AreEqual(0, new List <object>(allItemsRight).Count);
}
public void IndexerGetTest_GivenABlankBijective()
{
var bijective = new Bijective <string, int>();
var leftToRightIndexerGetFailed = false;
try
{
var rightElement = bijective["A"];
}
catch (ArgumentOutOfRangeException)
{
leftToRightIndexerGetFailed = true;
}
Assert.IsTrue(leftToRightIndexerGetFailed);
var rightToLeftIndexerGetFailed = false;
try
{
var leftElement = bijective[10];
}
catch (ArgumentOutOfRangeException)
{
rightToLeftIndexerGetFailed = true;
}
Assert.IsTrue(rightToLeftIndexerGetFailed);
}
public void GetAllReverseBijectionsTest_GivenBlankBijective()
{
var bijective = new Bijective <object, object>();
var allReverseBijections = bijective.GetAllReverseBijections();
Assert.AreEqual(0, new List <Tuple <object, object> >(allReverseBijections).Count);
}
public void GetAllLeftElementsTest_GivenABlankBijective()
{
var bijective = new Bijective <object, object>();
var allLeftElements = bijective.GetAllLeftElements();
Assert.AreEqual(0, new List <object>(allLeftElements).Count);
}
public void RemoveRightElementTest()
{
var bijective = new Bijective <string, int>();
try
{
bijective.RemoveRightElement(10);
}
catch
{
Assert.Fail();
}
bijective["A"] = 10;
bijective["B"] = 20;
bijective.RemoveRightElement(10);
Assert.IsFalse(bijective.LeftElementExists("A"));
Assert.IsFalse(bijective.RightElementExists(10));
var allLeftElementsList = new List <string>(bijective.GetAllLeftElements());
Assert.AreEqual(1, allLeftElementsList.Count);
Assert.IsTrue(allLeftElementsList.Contains("B"));
var allRightElementsList = new List <int>(bijective.GetAllRightElements());
Assert.AreEqual(1, allRightElementsList.Count);
Assert.IsTrue(allRightElementsList.Contains(20));
Assert.IsTrue(bijective.CanAddBijection("A", 10));
Assert.IsTrue(bijective.CanAddReverseBijection(10, "A"));
Tuple <string, int> bijection;
Assert.IsFalse(bijective.TryGetBijection("A", out bijection));
Assert.IsNull(bijection);
Tuple <int, string> reverseBijection;
Assert.IsFalse(bijective.TryGetReverseBijection(10, out reverseBijection));
Assert.IsNull(reverseBijection);
var allBijectionsList = new List <Tuple <string, int> >(bijective.GetAllBijections());
Assert.AreEqual(1, allBijectionsList.Count);
Assert.AreEqual("B", allBijectionsList[0].Item1);
Assert.AreEqual(20, allBijectionsList[0].Item2);
var allReverseBijectionsList = new List <Tuple <int, string> >(bijective.GetAllReverseBijections());
Assert.AreEqual(1, allReverseBijectionsList.Count);
Assert.AreEqual(20, allReverseBijectionsList[0].Item1);
Assert.AreEqual("B", allReverseBijectionsList[0].Item2);
}
public static Bijective <string, int> GetBijective1()
{
var bijective = new Bijective <string, int>();
bijective["A"] = 10;
bijective["B"] = 20;
bijective["C"] = 30;
return(bijective);
}
public void CanAddReverseBijectionTest()
{
var bijective = new Bijective <string, int>();
bijective[10] = "A";
Assert.IsFalse(bijective.CanAddReverseBijection(10, "A"));
Assert.IsFalse(bijective.CanAddReverseBijection(10, "B"));
Assert.IsFalse(bijective.CanAddReverseBijection(20, "A"));
Assert.IsTrue(bijective.CanAddReverseBijection(20, "B"));
}
public void CanAddBijectionTest()
{
var bijective = new Bijective <string, int>();
bijective["A"] = 10;
Assert.IsFalse(bijective.CanAddBijection("A", 10));
Assert.IsFalse(bijective.CanAddBijection("B", 10));
Assert.IsFalse(bijective.CanAddBijection("A", 20));
Assert.IsTrue(bijective.CanAddBijection("B", 20));
}
public void TryAddReverseBijectionTest()
{
var bijective = new Bijective <string, int>();
bijective[10] = "A";
Assert.IsFalse(bijective.TryAddReverseBijection(10, "A"));
Assert.IsFalse(bijective.TryAddReverseBijection(10, "B"));
Assert.IsFalse(bijective.TryAddReverseBijection(20, "A"));
Assert.IsTrue(bijective.TryAddReverseBijection(20, "B"));
Assert.IsTrue(bijective.LeftElementExists("B"));
Assert.IsTrue(bijective.RightElementExists(20));
var allLeftElementsList = new List <string>(bijective.GetAllLeftElements());
Assert.AreEqual(2, allLeftElementsList.Count);
Assert.IsTrue(allLeftElementsList.Contains("B"));
var allRightElementsList = new List <int>(bijective.GetAllRightElements());
Assert.AreEqual(2, allRightElementsList.Count);
Assert.IsTrue(allRightElementsList.Contains(20));
Assert.IsFalse(bijective.CanAddBijection("B", 20));
Assert.IsFalse(bijective.CanAddReverseBijection(20, "B"));
Tuple <string, int> bijection;
Assert.IsTrue(bijective.TryGetBijection("B", out bijection));
Assert.AreEqual("B", bijection.Item1);
Assert.AreEqual(20, bijection.Item2);
Tuple <int, string> reverseBijection;
Assert.IsTrue(bijective.TryGetReverseBijection(20, out reverseBijection));
Assert.AreEqual(20, reverseBijection.Item1);
Assert.AreEqual("B", reverseBijection.Item2);
var allBijectionsList = new List <Tuple <string, int> >(bijective.GetAllBijections());
Assert.AreEqual(2, allBijectionsList.Count);
Assert.IsTrue(allBijectionsList.Select(b => b.Item1).Contains("B"));
Assert.IsTrue(allBijectionsList.Select(b => b.Item2).Contains(20));
var allReverseBijectionsList = new List <Tuple <int, string> >(bijective.GetAllReverseBijections());
Assert.AreEqual(2, allReverseBijectionsList.Count);
Assert.IsTrue(allReverseBijectionsList.Select(b => b.Item1).Contains(20));
Assert.IsTrue(allReverseBijectionsList.Select(b => b.Item2).Contains("B"));
}
public void TryGetBijectionTest()
{
var bijective = new Bijective <string, int>();
Tuple <string, int> bijection;
Assert.IsFalse(bijective.TryGetBijection("A", out bijection));
Assert.IsNull(bijection);
bijective["A"] = 10;
Assert.IsTrue(bijective.TryGetBijection("A", out bijection));
Assert.IsNotNull(bijection);
Assert.AreEqual("A", bijection.Item1);
Assert.AreEqual(10, bijection.Item2);
}
public void TryGetReverseBijectionTest()
{
var bijective = new Bijective <string, int>();
Tuple <int, string> reverseBijection;
Assert.IsFalse(bijective.TryGetReverseBijection(10, out reverseBijection));
Assert.IsNull(reverseBijection);
bijective["A"] = 10;
Assert.IsTrue(bijective.TryGetReverseBijection(10, out reverseBijection));
Assert.IsNotNull(reverseBijection);
Assert.AreEqual(10, reverseBijection.Item1);
Assert.AreEqual("A", reverseBijection.Item2);
}
public void EncodeWithPadding_AlphabetIsAnEmptyString_ThrowsArgumentNullException()
{
var exception = Assert.Throws <ArgumentException>(() => Bijective.Encode(1, "", 10));
Assert.Contains("alphabet must not be an empty string", exception.Message);
}
public void EncodeWithPadding_AlphabetIsNull_ThrowsArgumentNullException()
{
var exception = Assert.Throws <ArgumentNullException>(() => Bijective.Encode(1, null, 10));
Assert.Contains("alphabet must not be null", exception.Message);
}
public void Encode_ValueLessThanZero_ThrowsArgumentOutOfRangeException()
{
var exception = Assert.Throws <ArgumentOutOfRangeException>(() => Bijective.Encode(-1, Alphabet.Base62));
Assert.Contains("value must be greater than or equal to zero", exception.Message);
}
public void Decode(int expected, string value, string alphabet)
{
Assert.Equal(expected, Bijective.Decode(value, alphabet));
}
public void EncodeWithPadding(string expected, int value, string alphabet, int padding)
{
Assert.Equal(expected, Bijective.Encode(value, alphabet, padding));
}
public void Encode(string result, int value, string alphabet)
{
Assert.Equal(result, Bijective.Encode(value, alphabet));
}
public void Decode_AlphabetIsAnEmptyString_ThrowsArgumentNullException()
{
var exception = Assert.Throws <ArgumentException>(() => Bijective.Decode("1", ""));
Assert.Contains("alphabet must not be an empty string", exception.Message);
}
public void Decode_AlphabetIsNull_ThrowsArgumentNullException()
{
var exception = Assert.Throws <ArgumentNullException>(() => Bijective.Decode("1", null));
Assert.Contains("alphabet must not be null", exception.Message);
}
public void Decode_ValueIsAnEmptyString_ThrowsArgumentNullException()
{
var exception = Assert.Throws <ArgumentException>(() => Bijective.Decode("", Alphabet.Base62));
Assert.Contains("value must not be an empty string", exception.Message);
}
public void EncodeWithPadding_PaddingLessThanZero_ThrowsArgumentOutOfRangeException()
{
var exception = Assert.Throws <ArgumentOutOfRangeException>(() => Bijective.Encode(1, Alphabet.Base62, -1));
Assert.Contains("padding must be greater than or equal to zero", exception.Message);
}
public void IndexerSetTest_GivenANonBlankBijective()
{
var bijective = new Bijective <string, int>();
bijective["A"] = 10;
var leftToRightIndexerSetFailed = false;
try
{
bijective["A"] = 10;
}
catch (ArgumentException)
{
leftToRightIndexerSetFailed = true;
}
Assert.IsTrue(leftToRightIndexerSetFailed);
leftToRightIndexerSetFailed = false;
try
{
bijective["A"] = 20;
}
catch (ArgumentException)
{
leftToRightIndexerSetFailed = true;
}
Assert.IsTrue(leftToRightIndexerSetFailed);
leftToRightIndexerSetFailed = false;
try
{
bijective["B"] = 10;
}
catch (ArgumentException)
{
leftToRightIndexerSetFailed = true;
}
Assert.IsTrue(leftToRightIndexerSetFailed);
var rightToLeftIndexerSetFailed = false;
try
{
bijective[10] = "A";
}
catch (ArgumentException)
{
rightToLeftIndexerSetFailed = true;
}
Assert.IsTrue(rightToLeftIndexerSetFailed);
rightToLeftIndexerSetFailed = false;
try
{
bijective[10] = "B";
}
catch (ArgumentException)
{
rightToLeftIndexerSetFailed = true;
}
Assert.IsTrue(rightToLeftIndexerSetFailed);
rightToLeftIndexerSetFailed = false;
try
{
bijective[20] = "A";
}
catch (ArgumentException)
{
rightToLeftIndexerSetFailed = true;
}
Assert.IsTrue(rightToLeftIndexerSetFailed);
}
public void Decode_ValueIsNull_ThrowsArgumentNullException()
{
var exception = Assert.Throws <ArgumentNullException>(() => Bijective.Decode(null, Alphabet.Base62));
Assert.Contains("value must not be null", exception.Message);
}
public string GetShortUri(int databaseId)
{
var shortUri = Bijective.Encode(databaseId);
return(shortUri);
}
