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]);*/ }