public void AddingAndRemovingPeopleMaintainsCorrectCount()
{
ArraySet set = new ArraySet();
var alice = new Person {
Name = "Alice"
};
var bob = new Person {
Name = "Bob"
};
var charlie = new Person {
Name = "Charlie"
};
Assert.AreEqual(0, set.Count());
set.Add(alice);
Assert.AreEqual(1, set.Count());
set.Add(bob);
Assert.AreEqual(2, set.Count());
set.Add(charlie);
Assert.AreEqual(3, set.Count());
set.Remove(bob);
Assert.AreEqual(2, set.Count());
set.Remove(charlie);
Assert.AreEqual(1, set.Count());
set.Remove(alice);
Assert.AreEqual(0, set.Count());
}
public void SetReturnsCorrectReferencesWhenPeopleAreRemoved()
{
ArraySet set = new ArraySet();
var alice = new Person {
Name = "Alice"
};
var bob = new Person {
Name = "Bob"
};
var charlie = new Person {
Name = "Charlie"
};
set.Add(alice);
set.Add(bob);
set.Add(charlie);
Person[] people = set.GetAllPeople();
Assert.AreEqual(3, people.Length);
Assert.IsTrue(people.Contains(alice));
Assert.IsTrue(people.Contains(bob));
Assert.IsTrue(people.Contains(charlie));
set.Remove(bob);
people = set.GetAllPeople();
Assert.AreEqual(2, people.Length);
Assert.IsTrue(people.Contains(alice));
Assert.IsTrue(people.Contains(charlie));
}
public ICursor FetchAllNotes()
{
var repo = new RemoteRepository();
var result = repo.GetAllEntries();
string[] columns = new string[] { "_id", "title", "body" };
MatrixCursor matrixCursor = new MatrixCursor(columns);
foreach (var r in result)
{
var set = new ArraySet();
set.Add(r.id);
set.Add(r.title.ToString());
set.Add(r.body.ToString());
matrixCursor.AddRow(set);
}
/*var set = new ArraySet();
* set.Add("1");
* set.Add("ZXC");
* set.Add("QWE");
*
* matrixCursor.AddRow(set);
* matrixCursor.AddRow(set);*/
return(matrixCursor);
//return this.db.Query(DatabaseTable, new[] { KeyRowId, KeyTitle, KeyBody }, null, null, null, null, null);
}
protected virtual void SetUp()
{
set = new ArraySet <int>();
set.Add(5);
set.Add(10);
set.Add(8);
}
public void ExistMustReturnFalseIfItemsNonExist()
{
ArraySet <int> arrSet = new ArraySet <int>();
arrSet.Add(1);
arrSet.Add(3);
Assert.IsFalse(SetUtils.Exists(arrSet, (item) => {
return(item == 2);
}));
}
public void ExistMustReturnTrueIfItemsExist()
{
ArraySet <int> arrSet = new ArraySet <int>();
arrSet.Add(1);
arrSet.Add(3);
Assert.IsTrue(SetUtils.Exists(arrSet, (item) => {
return(item == 1);
}));
}
public void AddingPersonMultipleTimesDoesNotChangeCount()
{
ArraySet set = new ArraySet();
var alice = new Person {
Name = "Alice"
};
set.Add(alice);
set.Add(alice);
Assert.AreEqual(1, set.Count());
}
/// <summary>
/// Given a
/// <c>Tree</c>
/// node
/// <paramref name="t"/>
/// , attempts to
/// return a list of nodes to which node
/// <paramref name="t"/>
/// has this
/// grammatical relation, with
/// <paramref name="t"/>
/// as the governor.
/// </summary>
/// <param name="t">Target for finding dependents of t related by this GR</param>
/// <param name="root">The root of the Tree</param>
/// <returns>A Collection of dependent nodes to which t bears this GR</returns>
public virtual ICollection <TreeGraphNode> GetRelatedNodes(TreeGraphNode t, TreeGraphNode root, IHeadFinder headFinder)
{
ICollection <TreeGraphNode> nodeList = new ArraySet <TreeGraphNode>();
foreach (TregexPattern p in targetPatterns)
{
// cdm: I deleted: && nodeList.isEmpty()
// Initialize the TregexMatcher with the HeadFinder so that we
// can use the same HeadFinder through the entire process of
// building the dependencies
TregexMatcher m = p.Matcher(root, headFinder);
while (m.FindAt(t))
{
TreeGraphNode target = (TreeGraphNode)m.GetNode("target");
if (target == null)
{
throw new AssertionError("Expression has no target: " + p);
}
nodeList.Add(target);
if (Debug)
{
log.Info("found " + this + "(" + t + "-" + t.HeadWordNode() + ", " + m.GetNode("target") + "-" + ((TreeGraphNode)m.GetNode("target")).HeadWordNode() + ") using pattern " + p);
foreach (string nodeName in m.GetNodeNames())
{
if (nodeName.Equals("target"))
{
continue;
}
log.Info(" node " + nodeName + ": " + m.GetNode(nodeName));
}
}
}
}
return(nodeList);
}
public void AddingMultiplePeopleMultipleTimesDoesNotChangeCount()
{
ArraySet set = new ArraySet();
var alice = new Person {
Name = "Alice"
};
var bob = new Person {
Name = "Bob"
};
set.Add(alice);
set.Add(bob);
set.Add(alice);
set.Add(bob);
Assert.AreEqual(2, set.Count());
}
public void AddTest()
{
for (int i = 0; i < 4; i++)
{
set.Add(i);
}
Assert.AreEqual("{0, 1, 2, 3}", set.ToString());
}
public void Setup()//Подставляет UnmutableSet в mySet перед каждым тестом
{
ArraySet <int> arrSet = new ArraySet <int>();
for (int i = 0; i < setLength; i++)
{
arrSet.Add(i);
}
mySet100 = new UnmutableSet <int>(arrSet);
}
public void ConvertAllReturnCorrectValue()
{
ArraySet <int> arrSet = new ArraySet <int>();
arrSet.Add(10);
Assert.IsInstanceOfType(SetUtils.ConvertAll <int, MySet.HashSet <int> >(arrSet), typeof(MySet.HashSet <int>));
Assert.IsInstanceOfType(SetUtils.ConvertAll <int, ArraySet <int> >(arrSet), typeof(ArraySet <int>));
Assert.IsInstanceOfType(SetUtils.ConvertAll <int, LinkedSet <int> >(arrSet), typeof(LinkedSet <int>));
}
private void PrepareForScheduling()
{
_unfinishedThreadIds = new ArraySet(_numThreads);
_waitingThreadIds = new ArraySet(_numThreads);
_threadIdsSeenWhileAllWaiting = new ArraySet(_numThreads);
for (int i = 0; i < _numThreads; ++i)
{
_unfinishedThreadIds.Add(i);
}
}
public void CountIsCorrect_1()
{
ArraySet set = new ArraySet();
set.Add(new Person {
Name = "Alice"
});
Assert.AreEqual(1, set.Count());
}
public void CountIsCorrect_5()
{
ArraySet set = new ArraySet();
set.Add(new Person {
Name = "Alice"
});
set.Add(new Person {
Name = "Bob"
});
set.Add(new Person {
Name = "Charlie"
});
set.Add(new Person {
Name = "Dolan"
});
set.Add(new Person {
Name = "Gooby"
});
Assert.AreEqual(5, set.Count());
}
public virtual void TestAdd()
{
NUnit.Framework.Assert.IsTrue(set.Contains(5));
NUnit.Framework.Assert.IsFalse(set.Contains(4));
for (int i = 0; i < 11; ++i)
{
set.Add(i);
}
// 0..10, existing elements should not be readded
NUnit.Framework.Assert.AreEqual(11, set.Count);
NUnit.Framework.Assert.IsTrue(set.Contains(5));
NUnit.Framework.Assert.IsTrue(set.Contains(4));
}
public void CountIsCorrect_10K()
{
ArraySet set = new ArraySet();
for (int i = 0; i < 10000; i++)
{
set.Add(new Person {
Name = $"Alice_{i}"
});
}
Assert.AreEqual(10000, set.Count());
}
public void IntersectionTest()
{
for (int i = 0; i < 4; i++)
{
set.Add(i);
}
ArraySet set1 = new ArraySet();
for (int i = 2; i < 6; i++)
{
set1.Add(i);
}
Assert.AreEqual("{2, 3}", set.Intersection(set1).ToString());
}
public void UnionTest()
{
for (int i = 0; i < 4; i++)
{
set.Add(i);
}
ArraySet set1 = new ArraySet();
for (int i = 2; i < 6; i++)
{
set1.Add(i);
}
Assert.AreEqual("{2, 3, 4, 5, 0, 1}", set.Union(set1).ToString());
}
public void DifferenceTest()
{
for (int i = 0; i < 4; i++)
{
set.Add(i);
}
ArraySet set1 = new ArraySet();
for (int i = 2; i < 6; i++)
{
set1.Add(i);
}
Assert.AreEqual("{0, 1}", set.Difference(set1).ToString());
}
public void ConvertAllReturnCorrectNumberOfElements()
{
ArraySet <int> arrSet = new ArraySet <int>();
int numOfElements = 50;
for (int i = 0; i < numOfElements; i++)
{
arrSet.Add(i);
}
Assert.AreEqual(numOfElements, SetUtils.ConvertAll <int, MySet.HashSet <int> >(arrSet).Count);
Assert.AreEqual(numOfElements, SetUtils.ConvertAll <int, ArraySet <int> >(arrSet).Count);
Assert.AreEqual(numOfElements, SetUtils.ConvertAll <int, LinkedSet <int> >(arrSet).Count);
}
public void CheckForAllReturnTrue()
{
ArraySet <int> arrSet = new ArraySet <int>();
int numOfElements = 50;
for (int i = 0; i < numOfElements; i++)
{
arrSet.Add(i);
}
Assert.IsTrue(SetUtils.CheckForAll <int>(arrSet, (item) => {
return(item >= 0 && item <= numOfElements);
}));
}
public static void Main()
{
ArraySet <string> sset = new ArraySet <string>();
ArraySet <Type> tset = new ArraySet <Type>();
ArraySet <int> iset = new ArraySet <int>();
ArraySet <Colour> cset = new ArraySet <Colour>();
sset.Add("A"); sset.Add("B");
iset.Add(1); iset.Add(2); iset.Add(3);
cset.Add(Colour.Red); cset.Add(Colour.Blue); cset.Add(Colour.Green);
tset.Add(typeof(string));
Console.WriteLine("sset = " + sset);
Console.WriteLine("iset = " + iset);
Console.WriteLine("cset = " + cset);
Console.WriteLine("tset = " + tset);
Console.WriteLine("sset X iset = " + sset.Cross <int>(iset));
Console.WriteLine("sset X tset = " + sset.Cross <Type>(tset));
Console.WriteLine("sset X sset = " + sset.Cross <string>(sset));
Console.WriteLine("sset X cset = " + sset.Cross <Colour>(cset));
Console.WriteLine("tset X sset = " + tset.Cross <string>(sset));
Console.WriteLine("tset X tset = " + tset.Cross <Type>(tset));
Console.WriteLine("tset X iset = " + tset.Cross <int>(iset));
Console.WriteLine("tset X cset = " + tset.Cross <Colour>(cset));
Console.WriteLine("iset X sset = " + iset.Cross <string>(sset));
Console.WriteLine("iset X tset = " + iset.Cross <Type>(tset));
Console.WriteLine("iset X iset = " + iset.Cross <int>(iset));
Console.WriteLine("iset X cset = " + iset.Cross <Colour>(cset));
Console.WriteLine("cset X sset = " + cset.Cross <string>(sset));
Console.WriteLine("cset X tset = " + cset.Cross <Type>(tset));
Console.WriteLine("cset X iset = " + cset.Cross <int>(iset));
Console.WriteLine("cset X cset = " + cset.Cross <Colour>(cset));
}
public ArraySet <Pair <T, U> > Cross <U>(ArraySet <U> that)
{
ArraySet <Pair <T, U> > result = new ArraySet <Pair <T, U> >();
int m = this.size;
int n = that.size;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
result.Add(new Pair <T, U>(this.items[i], that.items[j]));
}
}
return(result);
}
public void RemovingMultipleTimesDoesNotChangeCount()
{
ArraySet set = new ArraySet();
var alice = new Person {
Name = "Alice"
};
var bob = new Person {
Name = "Bob"
};
var charlie = new Person {
Name = "Charlie"
};
set.Add(alice);
set.Add(bob);
set.Add(charlie);
Assert.AreEqual(3, set.Count());
set.Remove(bob);
set.Remove(bob);
set.Remove(bob);
Assert.AreEqual(2, set.Count());
}
public void FindAllReturnCorrectValue()
{
ArraySet <int> arrSet = new ArraySet <int>();
for (int i = 0; i < 50; i++)
{
arrSet.Add(i);
}
ArraySet <int> newArrSet = SetUtils.FindAll <int, ArraySet <int> >(arrSet, (item) => {
return(item % 2 == 0);
});
foreach (int item in newArrSet)
{
Assert.IsTrue(item % 2 == 0);
}
Assert.AreEqual(25, newArrSet.Count);
}
public void ForEachRunFuncForEverItem()
{
ArraySet <int> arrSet = new ArraySet <int>();
int numOfElements = 50;
bool[] testArray = new bool[numOfElements];
for (int i = 0; i < numOfElements; i++)
{
arrSet.Add(i);
testArray[i] = false;
}
SetUtils.ForEach <int>(arrSet, (item) => {
testArray[item] = true;
});
for (int i = 0; i < numOfElements; i++)
{
Assert.IsTrue(testArray[i]);
}
}
public void SubsetTest()
{
for (int i = 0; i < 6; i++)
{
set.Add(i);
}
ArraySet set1 = new ArraySet();
for (int i = 2; i < 6; i++)
{
set1.Add(i);
}
ArraySet set2 = new ArraySet();
for (int i = 2; i < 7; i++)
{
set2.Add(i);
}
Assert.AreEqual(true, set.Subset(set1));
Assert.AreEqual(false, set.Subset(set2));
}
public bool ThreadWaiting(int waitingOnThreadId, object lockObject)
{
_waitingThreadIds.Add(RunningThreadId);
if (_waitingThreadIds.NumElems == NumUnfinishedThreads)
{
_threadIdsSeenWhileAllWaiting.Add(RunningThreadId);
}
else
{
_threadIdsSeenWhileAllWaiting.Clear();
}
bool deadlock = NumUnfinishedThreads == 1 || _threadIdsSeenWhileAllWaiting.NumElems == NumUnfinishedThreads;
int originalId = RunningThreadId;
if (!deadlock)
{
while (RunningThreadId == originalId)
{
MaybeSwitch();
}
}
return(deadlock);
}
public static void Procedure(ArraySet arrset, bool editing)
{
while (true)
{
char sex, maritalsts, grade;
int csex, cmaritalsts, cgrade = 0;
string fname, lname, saving, fpw, spw, id = "";
Person person = new Person("", "", "", 0, "", 0);
if (!editing)
{
id = numInput("\nEnter the ID: ");
}
else
{
id = numInput("\nEnter the ID of the record you want to edit: ");
//editing = !editing;
Console.WriteLine();
person = Finder(arrset, id);
if (person.Id == "")
{
return;
}
else
{
id = person.Id;
}
Console.WriteLine("\nProceed to make the changes!");
}
if (UniqueID(id) && !editing)
{
Console.WriteLine("\nThis ID has already been recorded.");
continue;
}
fname = stdInput("\nEnter the First Name: ");
lname = stdInput("\nEnter the Last Name: ");
int age = Convert.ToInt32(numInput("\nEnter the Age: "));
while (age < 7 || age > 120)
{
age = Convert.ToInt32(numInput("\nEnter the Age: "));
}
do
{
Console.WriteLine("\nEnter the Sex: [M|F]");
sex = Convert.ToChar(Console.ReadLine().ToUpper());
} while (sex != 'M' && sex != 'F');
if (sex == 'M')
{
csex = 1;
}
else
{
csex = 0;
}
do
{
Console.WriteLine("\nEnter the Marital Status: [S|M]");
maritalsts = Convert.ToChar(Console.ReadLine().ToUpper());
} while (maritalsts != 'S' && maritalsts != 'M');
if (maritalsts == 'M')
{
cmaritalsts = 1;
}
else
{
cmaritalsts = 0;
}
do
{
Console.WriteLine("\nEnter the Education Level: [I|M|G|P]");
grade = Convert.ToChar(Console.ReadLine().ToUpper());
} while (grade != 'I' && grade != 'M' && grade != 'G' && grade != 'P');
switch (grade)
{
case 'M':
cgrade = 1;
break;
case 'G':
cgrade = 2;
break;
case 'P':
cgrade = 3;
break;
}
saving = decInput("\nEnter the Savings: ");
do
{
fpw = pwInput("\nEnter the Password: "******"\nConfirm the Password: "******"\nPasswords do not match!");
}
} while (fpw != spw);
int data = Encode(age, sex, maritalsts, grade);
Console.WriteLine("\nSave [S]; Discard[D]; Exit[E]");
string Selection = Console.ReadLine();
switch (Selection.ToLower())
{
case "s":
Console.Clear();
if (!editing)
{
Person nperson = Person.FromCsvFile($"{id},{fname},{lname},{saving},{fpw},{data}");
bool add = arrset.Add(nperson);
if (add)
{
Console.WriteLine("\nRecord registered correctly!\n");
}
else
{
Console.WriteLine("\nRecord couldn't be registered!\n");
}
}
else
{
if (person.FullName != fname + " " + lname)
{
Console.WriteLine("\nChanges in the Full Name made successfully!");
}
if (person.Savings != Convert.ToDouble(saving))
{
Console.WriteLine("\nChanges in the Savings made successfully!");
}
if (person.Password != fpw)
{
Console.WriteLine("\nChanges in the Password made successfully!");
}
if (person.Age != age)
{
Console.WriteLine("\nChanges in the Age made successfully!");
}
if ((int)person.Sex != csex)
{
Console.WriteLine("\nChanges in the Sex made successfully!");
}
if ((int)person.MaritalStatus != cmaritalsts)
{
Console.WriteLine("\nChanges in the Marital Status made successfully!");
}
if ((int)person.Grade != cgrade)
{
Console.WriteLine("\nChanges in the Grade made successfully!");
}
if ((person.FullName == fname + " " + lname) && (person.Savings == Convert.ToDouble(saving)) && (person.Password == fpw) && (person.Age == age) && ((int)person.Sex == csex) && ((int)person.MaritalStatus == cmaritalsts) && ((int)person.Grade == cgrade))
{
Console.WriteLine("\nIt appears no changes has been made.");
}
var nperson = Person.FromCsvFile($"{id},{fname},{lname},{saving},{fpw},{data}");
bool edit = arrset.Edit(person, nperson);
if (edit)
{
Console.WriteLine("\nThe task was completed successfully.");
}
else
{
Console.WriteLine("\nThe task was not completed.");
}
}
break;
case "d":
Console.Clear();
if (editing)
{
Procedure(set, false);
}
else
{
Procedure(set, true);
}
break;
case "e":
Console.Clear();
break;
default:
Console.Clear();
Console.WriteLine("\nSomething went wrong, try again.");
break;
}
break;
}
}
