void dispatcher_SearchRequestAsked(List <IRequestObject> selectedObjects, SearchResponseHandler callback)
{
//该函数进行下列具体实现：首先进行Object中种类的识别和搜索。
//进行识别完毕后，如果是资源占多数，则调用资源搜索的函数。
//进行识别完毕后，如果是标签占多数，则调用标签搜索的函数。
SearchResponseArgs e = new SearchResponseArgs();
e.Result = new List <IRequestObject>();
e.Result_Attribute = new List <bool>();
int numberOfResources = 0;
int numberOfTags = 0;
List <Tag> selectedTags = new List <Tag>();
List <Resource> selectedResources = new List <Resource>();
foreach (IRequestObject reobj in selectedObjects)
{
if (reobj is Tag)
{
numberOfTags++;
selectedTags.Add((Tag)reobj);
}
else
{
numberOfResources++;
selectedResources.Add((Resource)reobj);
}
}
//系统默认如果圈住的资源数目大于或等于标签数目，则系统进行资源的搜索。
if (numberOfResources < numberOfTags)
{
List <Resource> res = coronaService.SearchResourcesFromTags(selectedTags);
List <Resource> resourceToBeRemoved = new List <Resource>();
foreach (Resource resc in res)
{
//此处出现异常。需在遍历的时候，首先应该确定出应该删除的资源，并将其存储。
if (!File.Exists(resc.ResourcePath))
{
resourceToBeRemoved.Add(resc);
}
}
//确定完需要删除的Resource并将其一一删除。
foreach (Resource resc in resourceToBeRemoved)
{
rescControl.CheckResource(resc, coronaService);
res.Remove(resc);
}
foreach (Resource resc in res)
{
e.Result.Add(rescControl.WrapResource(resc));
e.Result_Attribute.Add(true);
}
List <Tag> tags = coronaService.SearchTagsFromTags(selectedTags);
foreach (Tag tag in tags)
{
e.Result.Add(tag);
e.Result_Attribute.Add(false);
}
}
else
{
List <Tag> tags = coronaService.SearchTagsFromResources(selectedResources);
foreach (Tag tag in tags)
{
e.Result.Add(tag);
e.Result_Attribute.Add(true);
}
foreach (Resource resc in selectedResources)
{
e.Result.Add(rescControl.WrapResource(resc));
e.Result_Attribute.Add(false);
}
}
if (callback != null)
{
callback(e);
}
}
public void ICornaServiceTest()
{
/* 测试AddResource方法
* */
//add the first Resource，and the Id is copy to the Resource
Resource resrc1 = new Resource("Internet Explorer.exe",
@"c:\program files\Internet Explorer"); // TODO: 初始化为适当的值
target.AddResource(resrc1);
Assert.IsTrue(isnumberic(resrc1.ResourceID));
//add the second Resource
Resource resrc2 = new Resource("TTPlayer.exe",
@"D:\program files\TTPlayer\TTPlayer.exe");//TODO:初始化尾适当的值
target.AddResource(resrc2);
Assert.IsTrue(isnumberic(resrc2.ResourceID));
/* 测试AddTag
*/
//add the first Tag to the first Resource
Tag tag1 = new Tag("5.0版本"); // TODO: 初始化为适当的值
target.AddTag(tag1, resrc1);
Assert.IsTrue(isnumberic(tag1.TagID));
//add the second Tag to the second Resource
Tag tag2 = new Tag("5.5版本");
target.AddTag(tag2, resrc2);
Assert.IsTrue(isnumberic(tag2.TagID));
//add the third Tag to the first Resource
Tag tag3 = new Tag("浏览器");
target.AddTag(tag3, resrc1);
Assert.IsTrue(isnumberic(tag3.TagID));
//add the forth Tag to the second Resource
Tag tag4 = new Tag("音乐播放器");
target.AddTag(tag4, resrc2);
Assert.IsTrue(isnumberic(tag4.TagID));
/*测试RemoveTag
* */
string tagToRemoveID = tag1.TagID; // TODO: 初始化为适当的值
target.RemoveTag(tagToRemoveID);
List <Resource> resList1 = new List <Resource>();
resList1.Add(resrc1);
byte flag = 1;
foreach (Tag t in target.SearchTagsFromResources(resList1))
{
if (t.TagID == tag1.TagID)
{
flag = 0;
break;
}
}
Assert.AreEqual(1, flag);
/*测试修改标签ModifyTag
* */
//修改标签Tag4(考虑修改名字而不是修改标签的ID)
//怎么修改标签呢？要传递内容的参数，还是……？？
// Tag tempTag = tag4;
// target.ModifyTag(tag4);
// Assert.AreNotEqual(tempTag.TagName, tag4.TagName);
/*测试删除资源RemoveResource
* */
//删除资源resrc1
string resrcToRemoveID = resrc1.ResourceID; // TODO: 初始化为适当的值
target.RemoveResource(resrcToRemoveID);
List <Tag> tagList1 = new List <Tag>();
tagList1.Add(tag1);
tagList1.Add(tag3);
int flag1 = 1;
foreach (Resource rs in target.SearchResourcesFromTags(tagList1))
{
if (rs.ResourceID == resrc1.ResourceID)
{
flag1 = 0;
break;
}
}
Assert.AreEqual(1, flag1);
//为了便于测试现在把第一个资源在重新添加回去！！,假设AddResource能够为参数的ID属性赋值！
target.AddResource(resrc1);//这时resrc1的ID属性应该是发生了变化，只是我们不必知道而已
//把Tag1,Tag3重新添加到第一个资源中资源
target.AddTag(tag1, resrc1);
target.AddTag(tag3, resrc1);
/// <summary>
///SearchResourcesFromTags 的测试
///</summary>
List <Tag> selectedTags = new List <Tag>(); // TODO: 初始化为适当的值
selectedTags.Add(tag1);
selectedTags.Add(tag2);
selectedTags.Add(tag3);
List <Resource> ResListExpected = new List <Resource>(); // TODO: 初始化为适当的值
ResListExpected.Add(resrc1);
ResListExpected.Add(resrc2);
List <Resource> ResListActual;
ResListActual = target.SearchResourcesFromTags(selectedTags);
//不判断生成的List是否有重复的元素
//判断实际生成的List中，每个元素都在预期的List中，否则断言失败；
foreach (Resource r in ResListActual)
{
byte flag2 = 0;
foreach (Resource t in ResListExpected)
{
if (r.ResourceID == t.ResourceID)
{
flag2 = 1;
break;
}
}
if (flag2 == 0)
{
Assert.Fail();
}
}
//判断在预期的List中每个元素都属于生成的实际List，否则断言失败；
foreach (Resource r in ResListExpected)
{
byte flag2 = 0;
foreach (Resource t in ResListActual)
{
if (r.ResourceID == t.ResourceID)
{
flag2 = 1;
break;
}
}
if (flag2 == 0)
{
Assert.Fail();
}
}
//if tagList is null:
// List<Tag> selectedTags1 = null;//TODO: 初始化为适当的值
// List<Resource> ResListExpected1 = null;
// List<Resource> ResListActual1 = target.SearchResourcesFromTags(selectedTags1);
// Assert.AreEqual(ResListExpected1, ResListActual1);
//如果标签的内容一致，但是不是同一个标签，但是把它看成是一个标签，
//这时，需要根据标签的内容来进行检索标签；
Tag tagOfBoth0 = new Tag("创建时间：2009/11/19");
Tag tagOfBoth1 = new Tag("创建时间：2009/11/19");
target.AddTag(tagOfBoth0, resrc1);
target.AddTag(tagOfBoth1, resrc2);
List <Tag> tagList2 = new List <Tag>();
tagList2.Add(tagOfBoth0);
List <Resource> resListActual2;
resListActual2 = target.SearchResourcesFromTags(tagList2);
byte flag3 = 0;
foreach (Resource rs in resListActual2)
{
if (rs.ResourceID == resrc1.ResourceID)
{
flag3 = 1;
break;
}
}
if (flag3 == 1)
{
foreach (Resource rs in resListActual2)
{
if (rs.ResourceID == resrc2.ResourceID)
{
flag3 = 2;
break;
}
}
}
Assert.AreEqual(2, flag3);
/// <summary>
///SearchTagsFromResources 的测试
///</summary>
List <Resource> selectedResources = new List <Resource>(); // TODO: 初始化为适当的值
selectedResources.Add(resrc1);
selectedResources.Add(resrc2);
List <Tag> tagListExpected = new List <Tag>(); // TODO: 初始化为适当的值
tagListExpected.Add(tag1);
tagListExpected.Add(tag3);
tagListExpected.Add(tag2);
tagListExpected.Add(tag4);
tagListExpected.Add(tagOfBoth0);
tagListExpected.Add(tagOfBoth1);
List <Tag> tagListActual;
tagListActual = target.SearchTagsFromResources(selectedResources);
foreach (Tag r in tagListActual)
{
byte flag2 = 0;
foreach (Tag t in tagListExpected)
{
if (r.TagID == t.TagID)
{
flag2 = 1;
break;
}
}
if (flag2 == 0)
{
Assert.Fail();
}
}
//判断在预期的List中每个元素都属于生成的实际List，否则断言失败；
foreach (Tag r in tagListExpected)
{
byte flag2 = 0;
foreach (Tag t in tagListActual)
{
if (r.ResourceID == t.ResourceID)
{
flag2 = 1;
break;
}
}
if (flag2 == 0)
{
Assert.Fail();
}
}
//if selectedResources is null
// List<Resource> selectedResources1 = new List<Resource>();
// List<Tag> tagListExpected1 = null;
// List<Tag> tagListActual1;
// tagListActual1 = target.SearchTagsFromResources(selectedResources1);
// Assert.AreEqual(tagListExpected1, tagListActual1);
/*SearchTagsFromTagsTest的测试
*
* */
/*List<Tag> selectedTags2 = new List<Tag>();
* selectedTags2.Add(tag1);
* selectedTags2.Add(tag2);
* List<Tag> tagListActual2;
* tagListActual2 = target.SearchTagsFromTags(selectedTags2);
* Assert.IsTrue(tagListActual2.Contains(tag3) && tagListActual2.Contains(tag4) &&
* tagListActual2.Contains(tagOfBoth0) && tagListActual2.Contains(tagOfBoth1) &&
* !tagListActual2.Contains(tag1) && !tagListActual2.Contains(tag2));
* //if taglist is null
* selectedTags2.Clear();
* tagListActual2 = target.SearchTagsFromTags(selectedTags2);
* Assert.IsNull(tagListActual2);*/
}
