public void testBasicIntersection()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_fields2.Add("cat");
_fields2.Add("white");
_tuple2 = new Tuple(_fields2);
List <Tuple> list1 = new List <Tuple>();
List <Tuple> list2 = new List <Tuple>();
list1.Add(_tuple1);
list2.Add(_tuple2);
Assert.AreEqual(1, list1.Count);
Assert.AreEqual(1, list2.Count);
List <List <Tuple> > listOfListsOfTuples = new List <List <Tuple> >();
listOfListsOfTuples.Add(list1);
listOfListsOfTuples.Add(list2);
Assert.AreEqual(2, listOfListsOfTuples.Count);
IEnumerable <Tuple> intersection = FrontEndXL.Intersection(listOfListsOfTuples);
Assert.AreEqual(1, intersection.Count());
//tuple1 or tuple2 must be equals to the intersection
Assert.AreEqual(_tuple1, intersection.ElementAt(0));
Assert.AreEqual(_tuple2, intersection.ElementAt(0));
}
public void take1PhaseTest()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_fields2.Add("cat");
_fields2.Add("gray");
_tuple2 = new Tuple(_fields2);
_tupleSpace.write(1, 1, _tuple1);
_tupleSpace.write(1, 2, _tuple2);
//Check if the tuple space has the 2 elements we added right now
Assert.AreEqual(2, _tupleSpace.ItemCount());
List <Tuple> takeReturn = null;
takeReturn = _tupleSpace.take(1, 3, _tuple1);
Assert.IsNotNull(takeReturn);
//Only one tuple should be returned
Assert.AreEqual(1, takeReturn.Count);
Assert.AreEqual(_tuple1, takeReturn[0]);
}
public void takeUsingWildCards2Test()
{
_fields.Add("cat");
_fields.Add("white");
_fields2.Add("cat");
_fields2.Add("gray");
_fields3.Add("dog");
_fields3.Add("white");
_fields4.Add("*");
_fields4.Add("white");
_tuple1 = new Tuple(_fields);
_tuple2 = new Tuple(_fields2);
_tuple3 = new Tuple(_fields3);
_tuple4 = new Tuple(_fields4);
//write <cat,white>
_tupleSpaceSMR.write(_tuple1);
//write <cat,gray>
_tupleSpaceSMR.write(_tuple2);
//write <dog,white>
_tupleSpaceSMR.write(_tuple3);
Assert.AreEqual(3, _tupleSpaceSMR.ItemCount());
//take <*, white>
_tupleSpaceSMR.take(_tuple4);
Assert.AreEqual(2, _tupleSpaceSMR.ItemCount());
//take <*, white> again and remove the second one
_tupleSpaceSMR.take(_tuple4);
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
}
public void writeTest()
{
_fields = new List <object>();
_fields.Add("dog");
_fields.Add("brown");
Tuple tuple1 = new Tuple(_fields);
_tupleSpaceSMR.write(tuple1);
List <Tuple> tlist = _tupleSpaceSMR.GetTuples();
List <Tuple> testtlist = new List <Tuple>();
testtlist.Add(tuple1);
List <Object> testolist;
List <Object> test;
for (int i = 0; i < tlist.Count(); i++)
{
test = tlist.ElementAt(i).GetAllFields();
testolist = testtlist.ElementAt(i).GetAllFields();
if (test.Count() == testolist.Count())
{
for (int k = 0; k < test.Count(); k++)
{
Assert.IsTrue(test.ElementAt(k).Equals(testolist.ElementAt(k)));
}
}
}
}
public void readNotAvailableTest()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
Tuple readTuple = null;
Assert.AreEqual(0, _tupleSpaceSMR.ItemCount());
Assert.AreEqual(null, readTuple);
Task.Run(() =>
{
Thread.CurrentThread.IsBackground = true;
//lets delay the write in 1 second
Thread.Sleep(1000);
_tupleSpaceSMR.write(_tuple1);
return; //just to ensure that we stop the thread
});
Assert.AreEqual(0, _tupleSpaceSMR.ItemCount());
//current thread will be blocked here 1 second until write.
readTuple = _tupleSpaceSMR.read(_tuple1);
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
Assert.AreEqual(_tuple1, readTuple);
}
public void takeNotAvailableTest()
{
_fields.Add("cat");
_fields.Add("white");
_fields2.Add("dog");
_fields2.Add("brown");
_tuple1 = new Tuple(_fields);
_tuple2 = new Tuple(_fields2);
Assert.AreEqual(0, _tupleSpaceSMR.ItemCount());
//write <cat,white>
_tupleSpaceSMR.write(_tuple1);
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
Task.Run(() =>
{
Thread.CurrentThread.IsBackground = true;
//lets delay the write in 1 second
Thread.Sleep(1000);
_tupleSpaceSMR.write(_tuple2);
return; //just to ensure that we stop the thread
});
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
//take <dog, brown> which will only exists 1 sec ahead!
_tupleSpaceSMR.take(_tuple2);
//Even if we add <dog, brown> take operation will remove it so
//only <cat,white> should exists!
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
}
public void SimplewriteTest()
{
Assert.AreEqual(0, _tupleSpace.ItemCount());
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_tupleSpace.write(1, 1, _tuple1);
Assert.AreEqual(1, _tupleSpace.ItemCount());
}
public void testIntersectionWithDuplicates()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_fields2.Add("cat");
_fields2.Add("gray");
_tuple2 = new Tuple(_fields2);
_fields3.Add("dog");
_fields3.Add("brown");
_tuple3 = new Tuple(_fields3);
List <Tuple> list1 = new List <Tuple>();
List <Tuple> list2 = new List <Tuple>();
List <Tuple> list3 = new List <Tuple>();
//list1: [<cat, white>, <cat, gray>]
list1.Add(_tuple1);
list1.Add(_tuple2);
Assert.AreEqual(2, list1.Count);
//list2: [<cat, gray>, <dog, brown>]
list2.Add(_tuple2);
list2.Add(_tuple3);
Assert.AreEqual(2, list2.Count);
//list3: [<dog, brown>, <dog, brown>, <dog, brown>, <cat, gray>]
list3.Add(_tuple3);
list3.Add(_tuple3);
list3.Add(_tuple3);
list3.Add(_tuple2);
Assert.AreEqual(4, list3.Count);
List <List <Tuple> > listOfListsOfTuples = new List <List <Tuple> >();
listOfListsOfTuples.Add(list1);
listOfListsOfTuples.Add(list2);
listOfListsOfTuples.Add(list3);
Assert.AreEqual(3, listOfListsOfTuples.Count);
IEnumerable <Tuple> intersection = FrontEndXL.Intersection(listOfListsOfTuples);
Assert.AreEqual(1, intersection.Count());
Assert.AreEqual(_tuple2, intersection.ElementAt(0));
}
public void testIntersection()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_fields2.Add("cat");
_fields2.Add("gray");
_tuple2 = new Tuple(_fields2);
_fields3.Add("cat");
_fields3.Add("white");
_tuple3 = new Tuple(_fields3);
List <Tuple> list1 = new List <Tuple>();
List <Tuple> list2 = new List <Tuple>();
List <Tuple> list3 = new List <Tuple>();
//list1: [<cat, white>]
list1.Add(_tuple1);
Assert.AreEqual(1, list1.Count);
//list2: [<cat, gray>, <cat, white>]
list2.Add(_tuple2);
list2.Add(_tuple3);
Assert.AreEqual(2, list2.Count);
//list3: [<cat, white>]
list3.Add(_tuple3);
Assert.AreEqual(1, list3.Count);
List <List <Tuple> > listOfListsOfTuples = new List <List <Tuple> >();
listOfListsOfTuples.Add(list1);
listOfListsOfTuples.Add(list2);
listOfListsOfTuples.Add(list3);
Assert.AreEqual(3, listOfListsOfTuples.Count);
IEnumerable <Tuple> intersection = FrontEndXL.Intersection(listOfListsOfTuples);
Assert.AreEqual(1, intersection.Count());
//tuple1 or tuple3 must be equals to the intersection
Assert.AreEqual(_tuple1, intersection.ElementAt(0));
Assert.AreEqual(_tuple3, intersection.ElementAt(0));
}
public void readTest()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_tupleSpaceSMR.write(_tuple1);
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
_tupleSpaceSMR.read(_tuple1);
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
for (int i = 0; i < _tuple1.GetNumberOfFields(); i++)
{
Assert.IsTrue(_tuple1.GetFieldByNumber(i).Equals(_tupleSpaceSMR.GetTuples().ElementAt(0).GetFieldByNumber(i)));
}
}
public void takeTest()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
Assert.AreEqual(0, _tupleSpaceSMR.ItemCount());
_tupleSpaceSMR.write(_tuple1);
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
_tupleSpaceSMR.take(_tuple1);
Assert.AreEqual(0, _tupleSpaceSMR.ItemCount());
}
public void ConcurrentAddTakeTest()
{
_fields.Add("1");
_fields2.Add("2");
_tuple1 = new Tuple(_fields);
_tuple2 = new Tuple(_fields2);
Assert.AreEqual(0, _tupleSpace.ItemCount());
Task t0 = new Task(() =>
{
Thread.CurrentThread.IsBackground = true;
Thread.Sleep(1000);
for (int i = 0; i < 100; i++)
{
//add <"1">
_tupleSpace.write(1, 1 + i, _tuple1);
//take <"2">
_tupleSpace.take(1, 2 + i, _tuple2);
_tupleSpace.remove(_tuple2, 1);
}
return; //just to ensure that we stop the thread
});
Task t1 = new Task(() =>
{
Thread.CurrentThread.IsBackground = true;
for (int i = 0; i < 100; i++)
{
//add <"2">
_tupleSpace.write(2, 1 + i, _tuple2);
//take <"1">
_tupleSpace.take(2, 2 + i, _tuple1);
_tupleSpace.remove(_tuple1, 2);
}
return; //just to ensure that we stop the thread
});
t0.Start();
t1.Start();
t0.Wait();
t1.Wait();
Assert.AreEqual(0, _tupleSpace.ItemCount());
}
public void takeUsingWildCardsTest()
{
_fields.Add("cat");
_fields.Add("white");
_fields2.Add("cat");
_fields2.Add("*");
_tuple1 = new Tuple(_fields);
_tuple2 = new Tuple(_fields2);
Assert.AreEqual(0, _tupleSpaceSMR.ItemCount());
//write <cat,white>
_tupleSpaceSMR.write(_tuple1);
Assert.AreEqual(1, _tupleSpaceSMR.ItemCount());
//take <cat, *>
_tupleSpaceSMR.take(_tuple2);
Assert.AreEqual(0, _tupleSpaceSMR.ItemCount());
}
public void readIntensiveTest()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_fields2.Add("cat");
_fields2.Add("gray");
_tuple2 = new Tuple(_fields2);
_fields3.Add("dog");
_fields3.Add("brown");
_tuple3 = new Tuple(_fields3);
_fields4.Add("dog");
_fields4.Add("gray");
_tuple4 = new Tuple(_fields4);
_tupleSpace.write(1, 1, _tuple1);
Tuple readReturn = null;
readReturn = _tupleSpace.read(_tuple1);
Assert.IsNotNull(readReturn);
Assert.AreEqual(_tuple1, readReturn);
_tupleSpace.write(1, 2, _tuple2);
readReturn = _tupleSpace.read(_tuple2);
Assert.IsNotNull(readReturn);
Assert.AreEqual(_tuple2, readReturn);
//Two writes in a row
_tupleSpace.write(1, 3, _tuple3);
_tupleSpace.write(1, 4, _tuple4);
//This is not a mistake, first read 4 and then read 3
readReturn = _tupleSpace.read(_tuple4);
Assert.IsNotNull(readReturn);
Assert.AreEqual(_tuple4, readReturn);
readReturn = _tupleSpace.read(_tuple3);
Assert.IsNotNull(readReturn);
Assert.AreEqual(_tuple3, readReturn);
}
public void writeDuplicatesTest()
{
Assert.AreEqual(0, _tupleSpace.ItemCount());
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_fields2.Add("cat");
_fields2.Add("white");
_tuple2 = new Tuple(_fields2);
_tupleSpace.write(1, 1, _tuple1);
Assert.AreEqual(1, _tupleSpace.ItemCount());
_tupleSpace.write(1, 2, _tuple2);
Assert.AreEqual(2, _tupleSpace.ItemCount());
}
public void readUsingWildCardsTest()
{
_fields.Add("cat");
_fields.Add("white");
_tuple1 = new Tuple(_fields);
_fields2.Add("cat");
_fields2.Add("*");
_tuple2 = new Tuple(_fields2);
_tupleSpace.write(1, 1, _tuple1);
Tuple readReturn = null;
readReturn = _tupleSpace.read(_tuple2);
Assert.IsNotNull(readReturn);
Assert.AreEqual(_tuple1, readReturn);
}
public void takeNotAvailable1PhaseTest()
{
_fields.Add("cat");
_fields.Add("white");
_fields2.Add("dog");
_fields2.Add("brown");
_tuple1 = new Tuple(_fields);
_tuple2 = new Tuple(_fields2);
Assert.AreEqual(0, _tupleSpace.ItemCount());
//write <cat,white>
_tupleSpace.write(1, 1, _tuple1);
Assert.AreEqual(1, _tupleSpace.ItemCount());
Task.Run(() =>
{
Thread.CurrentThread.IsBackground = true;
//lets delay the write in 1 second
Thread.Sleep(1000);
_tupleSpace.write(2, 1, _tuple2);
return; //just to ensure that we stop the thread
});
Assert.AreEqual(1, _tupleSpace.ItemCount());
//take <dog, brown> which will only exists 1 sec ahead!
List <Tuple> takeResult = null;
takeResult = _tupleSpace.take(1, 2, _tuple2);
//Should exists 2 items <cat, white> and <dog, brown>
//Caution: This is a 1 phase take test
Assert.AreEqual(2, _tupleSpace.ItemCount());
Assert.IsNotNull(takeResult);
Assert.AreEqual(1, takeResult.Count);
Assert.AreEqual(_tuple2, takeResult[0]);
}
public Tuple Take(Tuple tuple)
{
Tuple returnTuple = tpool.AssyncInvoke(new ThrWork(tupleSpace.take));
return(tuple);
}
public void Add(Tuple tuple)
{
//Tuple returnTuple = tpool.AssyncInvoke(new VoidThrWork(tupleSpace.write));
}
public Tuple Read(Tuple tuple)
{
Tuple returnTuple = tpool.AssyncInvoke(new ThrWork(tupleSpace.read, new[] { tuple }));
return(tuple);
}
public void TwoTakeOnThreadsTest()
{
_fields.Add("cat");
_fields.Add("white");
_fields2.Add("dog");
_fields2.Add("brown");
_tuple1 = new Tuple(_fields);
_tuple2 = new Tuple(_fields2);
Assert.AreEqual(0, _tupleSpace.ItemCount());
//write <cat,white>
_tupleSpace.write(1, 1, _tuple1);
Assert.AreEqual(1, _tupleSpace.ItemCount());
Task t0 = new Task(() =>
{
Thread.CurrentThread.IsBackground = true;
//lets delay the write in 1 second
Thread.Sleep(1000);
//write <dog, brown>
_tupleSpace.write(2, 1, _tuple2);
Thread.Sleep(1000);
_tupleSpace.write(2, 2, _tuple2);
return; //just to ensure that we stop the thread
});
Task t1 = new Task(() =>
{
Thread.CurrentThread.IsBackground = true;
//performs a take concurrently
_tupleSpace.take(3, 1, _tuple2);
_tupleSpace.remove(_tuple2, 3);
return; //just to ensure that we stop the thread
});
Task t2 = new Task(() =>
{
Thread.CurrentThread.IsBackground = true;
//performs a take concurrently
_tupleSpace.take(4, 1, _tuple2);
_tupleSpace.remove(_tuple2, 4);
return; //just to ensure that we stop the thread
});
t0.Start();
t1.Start();
t2.Start();
t0.Wait();
t1.Wait();
t2.Wait();
Assert.AreEqual(1, _tupleSpace.ItemCount());
//take <dog, brown> which will only exists 1 sec ahead!
/*takeResult = _tupleSpace.take(1, 2, _tuple2);
*
* //Should exists 2 items <cat, white> and <dog, brown>
* //Caution: This is a 1 phase take test
* Assert.AreEqual(2, _tupleSpace.ItemCount());
*
* Assert.IsNotNull(takeResult);
*
* Assert.AreEqual(1, takeResult.Count);
*
* Assert.AreEqual(_tuple2, takeResult[0]);*/
}
