public void Example()
{
int expected = 6 * 9;
int actual = new RecentlyUsedList().Answer;
Assert.AreEqual(expected, actual);
}
public void ReturnGarimaWhenWeRetrievedFirstIndex()
{
RecentlyUsedList<string> ob = new RecentlyUsedList<string>(1);
ob.MyInsert("Garima");
Assert.AreEqual("Garima", ob[0]);
}
private void LoadSettings()
{
// Create the recently used list and pass it to the settings object
_recentlyUsed = new RecentlyUsedList(mnuFile, RecentlyUsedMenuIndex);
_recentlyUsed.Click += m_recentlyUsed_Click;
_settings.RecentlyUsedList = _recentlyUsed;
try
{
_settings.LoadXml();
}
catch (Exception ex)
{
// Handle the exception here, so we can continue running even if settings fail to load.
HandleException(ex);
}
_settings.MainWindow.ApplyToWindow(this);
Refresh();
mnuViewPreviewPane.Checked = _settings.PreviewPane;
mnuViewStatusBar.Checked = _settings.StatusBar;
mnuViewAutoScroll.Checked = _settings.AutoScrollMessages;
_recentlyUsed.Size = _settings.MaxRecentlyUsed;
}
public void Latest_recent_is_last()
{
var list = new RecentlyUsedList();
list.Add(25);
list.Add(32);
Assert.AreEqual(25, list.Last());
}
public void Most_recent_is_first()
{
var list = new RecentlyUsedList();
list.Add(25);
list.Add(32);
Assert.AreEqual(32, list.First());
}
public void ShouldReturnZeroWhenCountItemsIsCalledForInitialList()
{
RecentlyUsedList<int> ListObject = new RecentlyUsedList<int>(5);
int countItems=ListObject.CountItems();
Assert.AreEqual(0, countItems, "Initially The list is not Empty.");
}
public void Add_WhenFirstItemAdded_ReturnsTheAddedItemId()
{
var list = new RecentlyUsedList <int>();
list.Add("someId", 123);
list[0].Id.ShouldBe("someId");
}
public void ReturnFiveWhenWeRetrievedFirstIndex()
{
RecentlyUsedList<int> ob = new RecentlyUsedList<int>(2);
ob.MyInsert(3);
ob.MyInsert(5);
Assert.AreEqual(5, ob[0]);
Assert.AreEqual(3, ob[1]);
}
public void ShouldGiveFourIfFourIsAddedToIndexZeroAndReturnCountOne()
{
RecentlyUsedList<int> nums = new RecentlyUsedList<int>(5);
nums.AddItem(4);
int count = nums.NoOfElements();
Assert.AreEqual(1, count, "Expected value is 1");
Assert.AreEqual(4, nums[0], "Expected value is 4");
}
public void Add_WhenCalledOnce_ShouldReturnAddedItem()
{
var list = new RecentlyUsedList <int>();
list.Add("someId", 123);
list[0].Value.ShouldBe(123);
}
public void RecentlyUsedList_ImplementsIRecentlyUsedListInterface()
{
var list = new RecentlyUsedList <int>();
var iList = list as IRecentlyUsedList <int>;
iList.ShouldNotBeNull();
}
public void Add_WhenCalledTwiceWithSameValues_ShouldOnlyAddOne()
{
var list = new RecentlyUsedList <int>();
list.Add("someId", 123);
list.Add("someId", 123);
list.Count.ShouldBe(1);
}
public void Add_WhenCalledTwiceWithDifferentValues_ShouldContainTwoItems()
{
var list = new RecentlyUsedList <int>();
list.Add("someId", 123);
list.Add("secondId", 123);
list.Count.ShouldBe(2);
}
public void Add_WhenItemAdded_ShouldReturnItFirst()
{
var list = new RecentlyUsedList <int>();
list.Add("someId", 123);
list.Add("someId2", 124);
list[0].ShouldBe(("someId2", 124));
}
public void Add_WhenCalledTwiceWithTheSameId_ShoudContainSecondItem()
{
var list = new RecentlyUsedList <int>();
list.Add("someId", 123);
list.Add("someId", 124);
list[0].ShouldBe(("someId", 124));
}
public void ShouldInsertValuesIfFourIsAddedToIndexZeroAndFiveIsAddedToIndexOneAndReturnCountTwo()
{
RecentlyUsedList<int> nums = new RecentlyUsedList<int>(5);
nums.AddItem(4);
nums.AddItem(5);
int count = nums.NoOfElements();
Assert.AreEqual(2, count, "Expected value is 2");
Assert.AreEqual(5, nums[0], "Expected value is 5");
Assert.AreEqual(4, nums[1], "Expected value is 4");
}
public void Items_are_unique()
{
var list = new RecentlyUsedList();
list.Add(25);
list.Add(67);
list.Add(25);
list.Add(25);
Assert.AreEqual(25, list.Index(0));
Assert.AreEqual(67, list.Index(1));
}
public void ReturnOneWhenWeRetrievedSecondIndex()
{
RecentlyUsedList<int> ob = new RecentlyUsedList<int>(2);
ob.MyInsert(1);
ob.MyInsert(2);
ob.MyInsert(1);
ob.MyInsert(2);
Assert.AreEqual(2, ob[0]);
Assert.AreEqual(1, ob[1]);
}
public void ReturnThreeWhenFirstIndexIsRetrieved()
{
RecentlyUsedList<int> ob = new RecentlyUsedList<int>(2);
ob.MyInsert(1);
ob.MyInsert(2);
ob.MyInsert(3);
Assert.AreEqual(3, ob[0]);
Assert.AreEqual(2, ob[1]);
// Assert.AreEqual(1, ob[2]);
}
public void ShouldReturn_c_When_c_IsAddedLast()
{
RecentlyUsedList<string> ListObject = new RecentlyUsedList<string>(5);
ListObject.AddItem("Mohit");
ListObject.AddItem("Raj");
ListObject.AddItem("Atrey");
var item = ListObject[0];
Assert.AreEqual("Atrey", item, "The most recently added item is not the first item.");
}
public void ShouldGiveSixFiveFourIfFourIsAddedToIndexZeroAndFiveIsAddedToIndexOneAndSixIsAddedToIndexTwoAndReturnCountThree()
{
RecentlyUsedList<int> nums = new RecentlyUsedList<int>(5);
nums.AddItem(4);
nums.AddItem(5);
nums.AddItem(6);
int count = nums.NoOfElements();
Assert.AreEqual(3, count, "Expected value is 3");
Assert.AreEqual(6, nums[0], "Expected value is 6");
Assert.AreEqual(5, nums[1], "Expected value is 5");
Assert.AreEqual(4, nums[2], "Expected value is 4");
}
public void duplicate_insertions_are_moved()
{
var list = new RecentlyUsedList();
list.Add(25);
list.Add(67);
Assert.AreEqual(67, list.Index(0));
Assert.AreEqual(25, list.Index(1));
list.Add(25);
Assert.AreEqual(25, list.Index(0));
Assert.AreEqual(67, list.Index(1));
}
public void Items_accessed_by_index()
{
var list = new RecentlyUsedList();
list.Add(25);
list.Add(32);
list.Add(67);
list.Add(13);
Assert.AreEqual(13, list.Index(0));
Assert.AreEqual(67, list.Index(1));
Assert.AreEqual(32, list.Index(2));
Assert.AreEqual(25, list.Index(3));
}
public void ShouldGiveFiveAtZeroIndexIfFiveIsAddedToIndexFourAndItIsAlreadyAtIndexOneAndReturnFour()
{
RecentlyUsedList<int> nums = new RecentlyUsedList<int>(5);
nums.AddItem(4);
nums.AddItem(5);
nums.AddItem(6);
nums.AddItem(7);
nums.AddItem(5);
int count = nums.NoOfElements();
Assert.AreEqual(4, count, "Expected value is 4");
Assert.AreEqual(5, nums[0], "Expected value is 5");
Assert.AreEqual(4, nums[3], "Expected value is 4");
}
public void ShouldReturnEightWhenItemAtIndexOneIsCalled_AndEightShouldBeTheFirstElement()
{
RecentlyUsedList<int> ListObject = new RecentlyUsedList<int>(5);
ListObject.AddItem(12);
ListObject.AddItem(8);
ListObject.AddItem(5);
var item = ListObject[1];
Assert.AreEqual(8, item, "8 is not at the first index.");
Assert.AreEqual(8, ListObject[0], "8 is not the first item.");
}
public void Capacity_set_in_constructor_item_dropped_on_overflow()
{
var list = new RecentlyUsedList(3);
list.Add(33);
list.Add(67);
list.Add(87);
list.Add(55);
list.Add(88);
Assert.AreEqual(87, list.Index(0));
Assert.AreEqual(67, list.Index(1));
Assert.AreEqual(33, list.Index(2));
}
public void ShouldReturnThreeWhenCountItemsIsCalledAfterEightIsAddedAgainAndEightShouldBeTheFirstElement()
{
RecentlyUsedList<char> ListObject = new RecentlyUsedList<char>(5);
ListObject.AddItem('m');
ListObject.AddItem('a');
ListObject.AddItem('c');
ListObject.AddItem('a');
int countItems = ListObject.CountItems();
Assert.AreEqual(3, countItems, "The size of list is not Three");
Assert.AreEqual('a', ListObject[0], "a is not the first item.");
}
public void ShouldRemoveFourFromZeroIndexIfNineIsAddedToIndexFiveAndReturnCountFive()
{
RecentlyUsedList<int> nums = new RecentlyUsedList<int>(5);
nums.AddItem(4);
nums.AddItem(5);
nums.AddItem(6);
nums.AddItem(7);
nums.AddItem(8);
nums.AddItem(9);
int count = nums.NoOfElements();
Assert.AreEqual(5, count, "Expected value is 5");
Assert.AreEqual(9, nums[0], "Expected value is 9");
Assert.AreEqual(5, nums[4], "Expected value is 5");
}
public void ShouldReturnAtreyAsFirstItemAndEightAsLastItemIfAtreyIsAddedAfterListSizeIsFull()
{
RecentlyUsedList<int> ListObject = new RecentlyUsedList<int>(5);
ListObject.AddItem(11);
ListObject.AddItem(8);
ListObject.AddItem(6);
ListObject.AddItem(4);
ListObject.AddItem(13);
ListObject.AddItem(32);
var firstItem = ListObject[0];
var lastItem = ListObject[4];
int countItems = ListObject.CountItems();
Assert.AreEqual(32,firstItem , "The First item is not 32.");
Assert.AreEqual(8, lastItem, "The last item is not 8.");
Assert.AreEqual(5, countItems, "The size of list is not five");
}
static void Main(string[] args)
{
//RecentlyUsedList rul = new RecentlyUsedList();
//rul.AddItem("Mohit");
//rul.AddItem(1);
//rul.AddItem('c');
//rul.showList();
//Console.WriteLine(rul.SearchByIndex(1));
//rul.AddItem(1);
//rul.showList();
RecentlyUsedList<int> ListObject = new RecentlyUsedList<int>(5);
ListObject.AddItem(4);
ListObject.AddItem(8);
ListObject.AddItem(3);
ListObject.AddItem(4);
ListObject.AddItem(2);
ListObject.AddItem(1);
ListObject.ShowList();
Console.ReadKey();
}
public void UseTheRecentlyUsedList(RecentlyUsedList testee, int maximumElements)
{
"Given the maximum amount of elements is 3"
.x(() => maximumElements = 3);
("An an initialized list with a maximum amount of " + maximumElements + " elements")
.x(() => testee = new RecentlyUsedList(maximumElements));
("When add " + _firstElement)
.x(() => testee.Add(_firstElement));
("And I add " + _secondElement)
.x(() => testee.Add(_secondElement));
"Then the count should be 2"
.x(() => testee.Count.Should().Be(2));
("And the element at index 0 should have the value " + _secondElement)
.x(() => testee.LookUp(0).Should().Be(_secondElement));
("When add " + _firstElement)
.x(() => testee.Add(_firstElement));
"Then the count should remain 2"
.x(() => testee.Count.Should().Be(2));
("And the index 0 should have the value " + _firstElement)
.x(() => testee.LookUp(0).Should().Be(_firstElement));
("When add " + _thirdElement)
.x(() => testee.Add(_thirdElement));
("And I add " + _fourthElement)
.x(() => testee.Add(_fourthElement));
("Then the count should be " + maximumElements)
.x(() => testee.Count.Should().Be(maximumElements));
}
public void ThrowArgumentOutOfRangeExceptionWhenInvalidIndexIsRetrieved()
{
RecentlyUsedList<Employee> ob = new RecentlyUsedList<Employee>(2);
Employee e1 = new Employee();
Employee e2 = new Employee();
Employee e3 = new Employee();
ob.MyInsert(e1);
ob.MyInsert(e2);
ob.MyInsert(e3);
Assert.AreEqual(e3, ob[0]);
Assert.AreEqual(e2, ob[1]);
Assert.AreEqual(e1, ob[2]);
}
public void ThrowArgumentOutOfRangeExceptionWhenInvalidIndexIsPassedObjects()
{
RecentlyUsedList<Employee> ob = new RecentlyUsedList<Employee>(5);
Employee result = ob[0];
}
public void ReturnETwoWhenFirstIndexIsRetrieved()
{
RecentlyUsedList<Employee> ob = new RecentlyUsedList<Employee>(2);
Employee e1 = new Employee();
Employee e2 = new Employee();
ob.MyInsert(e1);
ob.MyInsert(e2);
Assert.AreEqual(e2, ob[0]);
Assert.AreEqual(e1, ob[1]);
}
public void ThrowArgumentOutOfRangeExceptionWhenInvalidIndexIsPassed()
{
RecentlyUsedList<int> ob = new RecentlyUsedList<int>(5);
int result = ob[0];
}
public void ReturnABCWhenFirstIndexIsRetrieved()
{
RecentlyUsedList<string> ob = new RecentlyUsedList<string>(2);
ob.MyInsert("Garima");
ob.MyInsert("Bhatia");
ob.MyInsert("abc");
Assert.AreEqual("abc", ob[0]);
}
public void ShouldThrowExecptionIfAccessValueAtIndexWhichIsEmpty()
{
RecentlyUsedList<string> nums = new RecentlyUsedList<string>(5);
nums.AddItem("abc");
nums.AddItem("xyz");
var a = nums[2];
}
public void Example()
{
int expected = 6 * 9;
int actual = new RecentlyUsedList().Answer;
Assert.AreEqual(expected, actual);
}
public void TearDown()
{
_recentlyUsedList = null;
_size = -1;
}
public void ShouldInsertValuesAccordinglyIfStringsAreAddedAndReturnCountTwo()
{
RecentlyUsedList<string> nums = new RecentlyUsedList<string>(5);
nums.AddItem("abc");
nums.AddItem("xyz");
int count = nums.NoOfElements();
Assert.AreEqual(2, count, "Expected value is 2");
Assert.AreEqual("xyz", nums[0], "Expected value is 5");
Assert.AreEqual("abc", nums[1], "Expected value is 4");
}
public RecentlyUsedListTests()
{
_testee = new RecentlyUsedList(MaximumNumbersInList);
}
public void ThrowArgumentOutOfRangeExceptionWhenInvalidIndexIsRetrievedWithStrings()
{
RecentlyUsedList<string> ob = new RecentlyUsedList<string>(2);
ob.MyInsert("Garima");
ob.MyInsert("Bhatia");
string result = ob[2];
}
public void ShouldGiveZeroIfArrayIsEmpty()
{
RecentlyUsedList<int> nums = new RecentlyUsedList<int>(5);
int count=nums.NoOfElements();
Assert.AreEqual(0,count , "Expected value is 0");
}
public void Setup()
{
_recentlyUsedList = new RecentlyUsedList<string>();
_size = 10;
}
public void ShouldAddClassObjectIntoListAccordinglyIfDuplicateObjectIsAdded()
{
RecentlyUsedList<Employee> nums = new RecentlyUsedList<Employee>(5);
Employee e1 = new Employee { Age = 24, Name = "Arjita" };
Employee e2 = new Employee { Age = 22, Name = "Garima" };
//Employee e3 = new Employee { Age = 24, Name = "Arjita" };
nums.AddItem(e1);
nums.AddItem(e2);
nums.AddItem(e1);
int count = nums.NoOfElements();
Assert.AreEqual(2, count, "Expected value is 2");
Assert.AreEqual(24, nums[0].Age, "Expected value is 24");
Assert.AreEqual("Arjita", nums[0].Name, "Expected value is Arjita");
Assert.AreEqual(22, nums[1].Age, "Expected value is 22");
Assert.AreEqual("Garima", nums[1].Name, "Expected value is Garima");
}
public void CanDefineListSize()
{
var sizeableList = new RecentlyUsedList<string>(_size);
Assert.That(_size, Is.EqualTo(sizeableList.Size));
}
public void ShouldAddClassObjectsIntoListAccordinglyIfOverFlowOccurs()
{
RecentlyUsedList<Employee> nums = new RecentlyUsedList<Employee>(5);
Employee e1 = new Employee { Age = 24, Name = "Arjita" };
Employee e2 = new Employee { Age = 22, Name = "Garima" };
Employee e3 = new Employee { Age = 24, Name = "Mohit" };
Employee e4 = new Employee { Age = 21, Name = "Arjita" };
Employee e5 = new Employee { Age = 23, Name = "Garima" };
Employee e6 = new Employee { Age = 21, Name = "Mohit" };
nums.AddItem(e1);
nums.AddItem(e2);
nums.AddItem(e3);
nums.AddItem(e4);
nums.AddItem(e5);
nums.AddItem(e6);
int count = nums.NoOfElements();
Assert.AreEqual(5, count, "Expected value is 5");
Assert.AreEqual(21, nums[0].Age, "Expected value is 21");
Assert.AreEqual("Mohit", nums[0].Name, "Expected value is Mohit");
Assert.AreEqual(23, nums[1].Age, "Expected value is 23");
Assert.AreEqual("Garima", nums[1].Name, "Expected value is Garima");
Assert.AreEqual(21, nums[2].Age, "Expected value is 21");
Assert.AreEqual("Arjita", nums[2].Name, "Expected value is Arjita");
Assert.AreEqual(24, nums[3].Age, "Expected value is 24");
Assert.AreEqual("Mohit", nums[3].Name, "Expected value is Mohit");
Assert.AreEqual(22, nums[4].Age, "Expected value is 22");
Assert.AreEqual("Garima", nums[4].Name, "Expected value is Garima");
}
