using HellMapManager.Helpers;

using HellMapManager.Models;

namespace TestProject;

public class ModelTest

{

[Fact]

public void TestBase()

{

var data = new Data("key", "Value");

Data data2;

data2 = data.Clone();

Assert.True(data.Equal(data2));

Assert.True(data2.Validated());

data2.Key = "";

Assert.False(data.Equal(data2));

Assert.False(data2.Validated());

data2 = data.Clone();

data2.Value = "";

Assert.False(data.Equal(data2));

Assert.False(data2.Validated());

var con = new Condition("cond", true);

Condition con2;

con2 = con.Clone();

Assert.True(con.Equal(con2));

Assert.True(con2.Validated());

con2 = con.Clone();

con2.Key = "";

Assert.False(con.Equal(con2));

Assert.False(con2.Validated());

con2 = con.Clone();

con2.Not = false;

Assert.False(con.Equal(con2));

Assert.True(con2.Validated());

var tc = new TypedConditions("key", ["1", "2"], true);

TypedConditions tc2;

tc2 = tc.Clone();

Assert.True(tc.Equal(tc2));

Assert.True(tc2.Validated());

tc2 = tc.Clone();

tc2.Key = "";

Assert.False(tc.Equal(tc2));

Assert.False(tc2.Validated());

tc2 = tc.Clone();

tc2.Conditions[0] = "0";

Assert.False(tc.Equal(tc2));

Assert.True(tc2.Validated());

tc2 = tc.Clone();

tc2.Conditions.Add("3");

Assert.False(tc.Equal(tc2));

Assert.True(tc2.Validated());

tc2 = tc.Clone();

tc2.Not = false;

Assert.False(tc.Equal(tc2));

Assert.True(tc2.Validated());

var vt = new ValueTag("key", 1);

ValueTag vt2;

vt2 = vt.Clone();

Assert.True(vt.Equal(vt2));

Assert.True(vt2.Validated());

Assert.Equal("key", vt2.ToString());

vt2 = vt.Clone();

vt2.Key = "";

Assert.False(vt.Equal(vt2));

Assert.False(vt2.Validated());

Assert.Equal("", vt2.ToString());

vt2 = vt.Clone();

vt2.Value = -1;

Assert.False(vt.Equal(vt2));

Assert.True(vt2.Validated());

Assert.Equal("key:-1", vt2.ToString());

vt2 = vt.Clone();

vt2.Value = 2;

vt2.Key = "key2";

Assert.False(vt.Equal(vt2));

Assert.Equal("key2:2", vt2.ToString());

Assert.True(vt.Match("key", 0));

Assert.True(vt.Match("key", -1));

Assert.False(vt.Match("key", 2));

Assert.False(vt.Match("key2", 0));

var vc = new ValueCondition("key", 1, true);

ValueCondition vc2;

vc2 = vc.Clone();

Assert.True(vc.Equal(vc2));

Assert.True(vc2.Validated());

Assert.Equal("!key", vc2.ToString());

Assert.Equal("key", vc2.KeyLabel);

vc2 = vc.Clone();

vc2.Key = "";

Assert.False(vc.Equal(vc2));

Assert.False(vc2.Validated());

Assert.Equal("!", vc2.ToString());

Assert.Equal("", vc2.KeyLabel);

vc2 = vc.Clone();

vc2.Value = -1;

Assert.False(vc.Equal(vc2));

Assert.True(vc2.Validated());

Assert.Equal("!key:-1", vc2.ToString());

Assert.Equal("key:-1", vc2.KeyLabel);

vc2 = vc.Clone();

vc2.Not = false;

vc2.Value = 1;

vc2.Key = "key2";

Assert.False(vc.Equal(vc2));

Assert.True(vc2.Validated());

Assert.Equal("key2", vc2.ToString());

Assert.Equal("key2", vc2.KeyLabel);

List<ValueTag> tags = [

new ("key1", 1),

new ("key2", 5),

];

Assert.True(ValueTag.HasTag(tags, "key1", 1));

Assert.True(ValueTag.HasTag(tags, "key2", 5));

Assert.False(ValueTag.HasTag(tags, "key1", 2));

Assert.False(ValueTag.HasTag(tags, "key2", 6));

Assert.False(ValueTag.HasTag(tags, "key3", 1));

Assert.True(ValueTag.HasTag(tags, "key3", 0));

Assert.True(ValueTag.ValidateConditions([], []));

Assert.False(ValueTag.ValidateConditions([], [new("key1", 1, false)]));

Assert.True(ValueTag.ValidateConditions(tags, []));

Assert.True(ValueTag.ValidateConditions(tags, [new("key1", 1, false)]));

Assert.False(ValueTag.ValidateConditions(tags, [new("key1", 1, true)]));

Assert.True(ValueTag.ValidateConditions(tags, [new("key1", 1, false), new("key2", 0, false)]));

Assert.True(ValueTag.ValidateConditions(tags, [new("key1", 1, false), new("key2", 10, true)]));

Assert.False(ValueTag.ValidateConditions(tags, [new("key1", 1, false), new("key2", 10, false)]));

Assert.False(ValueTag.ValidateConditions(tags, [new("key1", 1, false), new("key2", 4, true)]));

Assert.False(ValueTag.ValidateConditions(tags, [new("key1", 1, true), new("key2", 1, false)]));

Assert.True(ValueTag.ValidateConditions(tags, [new("key1", 1, false), new("key3", 1, true)]));

Assert.False(ValueTag.ValidateConditions(tags, [new("key1", 1, false), new("key3", 1, false)]));

}

[Fact]

public void TestValueTag()

{

var kv = new KeyValue("key", "value");

var tag = kv.ToValueTag();

Assert.Equal("key", tag.Key);

Assert.Equal(1, tag.Value);

kv = new KeyValue("key", "");

tag = kv.ToValueTag();

Assert.Equal("key", tag.Key);

Assert.Equal(1, tag.Value);

kv = new KeyValue("key", "1");

tag = kv.ToValueTag();

Assert.Equal("key", tag.Key);

Assert.Equal(1, tag.Value);

kv = new KeyValue("key", "0");

tag = kv.ToValueTag();

Assert.Equal("key", tag.Key);

Assert.Equal(0, tag.Value);

kv = new KeyValue("key", "2");

tag = kv.ToValueTag();

Assert.Equal("key", tag.Key);

Assert.Equal(2, tag.Value);

kv = new KeyValue("key", "-1");

tag = kv.ToValueTag();

Assert.Equal("key", tag.Key);

Assert.Equal(-1, tag.Value);

tag = new ValueTag("key", 0);

kv = KeyValue.FromValueTag(tag);

Assert.Equal("key", kv.Key);

Assert.Equal("0", kv.Value);

tag = new ValueTag("key", -1);

kv = KeyValue.FromValueTag(tag);

Assert.Equal("key", kv.Key);

Assert.Equal("-1", kv.Value);

tag = new ValueTag("key", 1);

kv = KeyValue.FromValueTag(tag);

Assert.Equal("key", kv.Key);

Assert.Equal("", kv.Value);

tag = new ValueTag("key", 2);

kv = KeyValue.FromValueTag(tag);

Assert.Equal("key", kv.Key);

Assert.Equal("2", kv.Value);

}

[Fact]

public void TestValueCondition()

{

var kv = new ToggleKeyValue("key", "value", false);

var vc = kv.ToValueCondition();

Assert.Equal("key", vc.Key);

Assert.Equal(1, vc.Value);

Assert.False(vc.Not);

kv = new ToggleKeyValue("key", "", true);

vc = kv.ToValueCondition();

Assert.Equal("key", vc.Key);

Assert.Equal(1, vc.Value);

Assert.True(vc.Not);

kv = new ToggleKeyValue("key", "1", false);

vc = kv.ToValueCondition();

Assert.Equal("key", vc.Key);

Assert.Equal(1, vc.Value);

Assert.False(vc.Not);

kv = new ToggleKeyValue("key", "0", true);

vc = kv.ToValueCondition();

Assert.Equal("key", vc.Key);

Assert.Equal(0, vc.Value);

Assert.True(vc.Not);

kv = new ToggleKeyValue("key", "2", false);

vc = kv.ToValueCondition();

Assert.Equal("key", vc.Key);

Assert.Equal(2, vc.Value);

Assert.False(vc.Not);

kv = new ToggleKeyValue("key", "-1", true);

vc = kv.ToValueCondition();

Assert.Equal("key", vc.Key);

Assert.Equal(-1, vc.Value);

Assert.True(vc.Not);

vc = new ValueCondition("key", 0, false);

kv = ToggleKeyValue.FromValueCondition(vc);

Assert.Equal("key", kv.Key);

Assert.Equal("0", kv.Value);

Assert.False(kv.Not);

vc = new ValueCondition("key", -1, true);

kv = ToggleKeyValue.FromValueCondition(vc);

Assert.Equal("key", kv.Key);

Assert.Equal("-1", kv.Value);

Assert.True(kv.Not);

vc = new ValueCondition("key", 1, false);

kv = ToggleKeyValue.FromValueCondition(vc);

Assert.Equal("key", kv.Key);

Assert.Equal("", kv.Value);

Assert.False(kv.Not);

vc = new ValueCondition("key", 2, true);

kv = ToggleKeyValue.FromValueCondition(vc);

Assert.Equal("key", kv.Key);

Assert.Equal("2", kv.Value);

Assert.True(kv.Not);

}

[Fact]

public void TestExit()

{

var exit = new Exit()

{

To = "to",

Command = "cmd",

Cost = 2,

Conditions = [new ValueCondition("con1", 1, false), new ValueCondition("con2", 1, true)]

};

Exit exit2;

exit2 = exit.Clone();

Assert.True(exit.Equal(exit2));

Assert.True(exit2.Validated());

exit2 = exit.Clone();

exit2.Command = "";

Assert.False(exit.Equal(exit2));

Assert.False(exit2.Validated());

exit2 = exit.Clone();

exit2.To = "";

Assert.False(exit.Equal(exit2));

Assert.True(exit2.Validated());

exit2 = exit.Clone();

exit2.Cost = -1;

Assert.False(exit.Equal(exit2));

Assert.True(exit2.Validated());

exit2 = exit.Clone();

exit2.Conditions[0].Key = "wrongkey";

Assert.False(exit.Equal(exit2));

Assert.True(exit2.Validated());

exit2 = exit.Clone();

exit2.Conditions.Add(new("con3", 0, true));

Assert.False(exit.Equal(exit2));

Assert.True(exit2.Validated());

exit2 = exit.Clone();

Assert.True(exit2.HasCondition);

Assert.Equal("con1,! con2", exit2.AllConditions);

exit2 = exit.Clone();

exit2.Conditions = [];

Assert.False(exit2.HasCondition);

Assert.Equal("", exit2.AllConditions);

List<ExitLabel> labels;

exit2 = exit.Clone();

labels = exit2.Labels;

Assert.Equal(5, labels.Count);

Assert.Equal(ExitLabel.Types.Command, labels[0].Type);

Assert.Equal("cmd", labels[0].Value);

Assert.True(labels[0].IsCommand);

Assert.False(labels[0].IsTo);

Assert.False(labels[0].IsCondition);

Assert.False(labels[0].IsExCondition);

Assert.False(labels[0].IsCost);

Assert.Equal(ExitLabel.Types.To, labels[1].Type);

Assert.Equal("to", labels[1].Value);

Assert.False(labels[1].IsCommand);

Assert.True(labels[1].IsTo);

Assert.False(labels[1].IsCondition);

Assert.False(labels[1].IsExCondition);

Assert.False(labels[1].IsCost);

Assert.Equal(ExitLabel.Types.Condition, labels[2].Type);

Assert.Equal("con1", labels[2].Value);

Assert.False(labels[2].IsCommand);

Assert.False(labels[2].IsTo);

Assert.True(labels[2].IsCondition);

Assert.False(labels[2].IsExCondition);

Assert.False(labels[2].IsCost);

Assert.Equal(ExitLabel.Types.ExCondition, labels[3].Type);

Assert.Equal("con2", labels[3].Value);

Assert.False(labels[3].IsCommand);

Assert.False(labels[3].IsTo);

Assert.False(labels[3].IsCondition);

Assert.True(labels[3].IsExCondition);

Assert.False(labels[3].IsCost);

Assert.Equal(ExitLabel.Types.Cost, labels[4].Type);

Assert.Equal("2", labels[4].Value);

Assert.False(labels[4].IsCommand);

Assert.False(labels[4].IsTo);

Assert.False(labels[4].IsCondition);

Assert.False(labels[4].IsExCondition);

Assert.True(labels[4].IsCost);

exit2 = new Exit();

exit2.Command = "cmd";

exit2.To = "to";

Assert.Equal(1, exit2.Cost);

labels = exit2.Labels;

Assert.Equal(2, labels.Count);

Assert.Equal(ExitLabel.Types.Command, labels[0].Type);

Assert.Equal("cmd", labels[0].Value);

Assert.Equal(ExitLabel.Types.To, labels[1].Type);

Assert.Equal("to", labels[1].Value);

}

[Fact]

public void TestRoom()

{

var room = new Room()

{

Key = "key",

Name = "name",

Group = "group",

Desc = "desc",

Tags = [new ValueTag("tag1", 1), new ValueTag("tag2", 1)],

Data = [new Data("dkey1", "dval1"), new Data("dkey2", "dval2")],

Exits = [

new Exit(){

Command="command1",

To="to1",

Cost=2,

Conditions=[

new ValueCondition("con1",0,true),

new ValueCondition("con2",0,false),

]

},

new Exit(){

Command="command2",

To="to2",

Cost=4,

}

]

};

Assert.True(room.HasTag("tag1", 0));

Assert.True(room.HasTag("tag2", 0));

Assert.False(room.HasTag("notexists", 1));

Assert.Equal("dval1", room.GetData("dkey1"));

Assert.Equal("dval2", room.GetData("dkey2"));

Assert.Equal("", room.GetData("notfound"));

Room room2;

Assert.False(room.Filter(FilterHelper.ParseKeyword("unknow")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("key")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("key=ke")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("name")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("name=nam")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("name=name")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("group")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("group=gro")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("tag1")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("tag=tag")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("tag=tag1")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("dkey1")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("misc=dkey")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("misc=dkey1")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("dval2")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("misc=dval")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("misc=dval2")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("command1")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("command=command")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("command=command1")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("to2")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("to=to")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("to=to2")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("on1")));

Assert.False(room.Filter(FilterHelper.ParseKeyword("tag=con")));

Assert.True(room.Filter(FilterHelper.ParseKeyword("tag=con1")));

Assert.Equal(2, room.ExitsCount);

Assert.Equal("tag1,tag2", room.AllTags);

Assert.False(room.HasExitTo("to999"));

Assert.True(room.HasExitTo("to1"));

Assert.True(room.HasExitTo("to2"));

room2 = room.Clone();

Assert.True(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Key = "";

Assert.False(room2.Validated());

Assert.False(room.Equal(room2));

room2 = room.Clone();

room2.Desc = "";

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Group = "";

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Desc = "";

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Tags[1] = new ValueTag("", 0);

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Tags.Add(new ValueTag("", 0));

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Exits[0].To = "";

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Exits.Add(new Exit());

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Data[0].Value = "";

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

room2 = room.Clone();

room2.Data.Add(new Data("", ""));

Assert.False(room.Equal(room2));

Assert.True(room2.Validated());

var room3 = new Room();

Assert.Equal(-1, room3.NumberID);

room3.Key = "1";

Assert.Equal(1, room3.NumberID);

room3.Key = " 2";

Assert.Equal(2, room3.NumberID);

room3.Key = "-1";

Assert.Equal(-1, room3.NumberID);

room3.Key = "abc";

Assert.Equal(-1, room3.NumberID);

}

[Fact]

public void TestRoomFilter()

{

var rf = new RoomFilter();

var room = new Room()

{

Key = "key",

Name = "name",

Group = "group",

Desc = "desc",

Tags = [new ValueTag("tag1", 1), new ValueTag("tag2", 1)],

Data = [new Data("dkey1", "dval1"), new Data("dkey2", "dval2")],

Exits = [

new Exit(){

Command="command1",

To="to1",

Cost=2,

Conditions=[

new ValueCondition("con1",1,true),

new ValueCondition("con2",1,false),

]

},

new Exit(){

Command="command2",

To="to2",

Cost=4,

}

]

};

Assert.True(rf.Validate(room));

rf.ContainsAnyKey = ["key1", "name2"];

Assert.False(rf.Validate(room));

rf.ContainsAnyKey = ["ke", "name2"];

Assert.True(rf.Validate(room));

rf.ContainsAnyKey = [];

Assert.True(rf.Validate(room));

rf.HasAnyName = ["nam", "name2"];

Assert.False(rf.Validate(room));

rf.HasAnyName = ["name", "name2"];

Assert.True(rf.Validate(room));

rf.HasAnyName = [];

Assert.True(rf.Validate(room));

rf.ContainsAnyName = ["name1", "name2"];

Assert.False(rf.Validate(room));

rf.ContainsAnyName = ["na", "name2"];

Assert.True(rf.Validate(room));

rf.ContainsAnyName = [];

Assert.True(rf.Validate(room));

rf.HasAnyExitTo = ["to3", "to4"];

Assert.False(rf.Validate(room)); ;

rf.HasAnyExitTo = ["to3", "to2"];

Assert.True(rf.Validate(room));

rf.HasAnyExitTo = [];

rf.HasAnyData = [new("dkey1", "dval"), new("dkey2", "dval3")];

Assert.False(rf.Validate(room)); ;

rf.HasAnyData = [new("dkey1", "dval1"), new("dkey2", "dval3")];

Assert.True(rf.Validate(room));

rf.HasAnyData = [];

rf.ContainsAnyData = [new("dkey1", "dval2"), new("dkey2", "dval3")];

Assert.False(rf.Validate(room)); ;

rf.ContainsAnyData = [new("dkey1", "dval"), new("dkey2", "dval3")];

Assert.True(rf.Validate(room));

rf.ContainsAnyData = [];

rf.RoomConditions = [new ValueCondition("tag1", 1, true), new ValueCondition("tag2", 1, false)];

Assert.False(rf.Validate(room)); ;

rf.RoomConditions = [new ValueCondition("tag1", 2, true), new ValueCondition("tag2", 1, false)];

Assert.True(rf.Validate(room));

rf.ContainsAnyData = [];

rf.HasAnyGroup = ["group1", "group2"];

Assert.False(rf.Validate(room));

rf.HasAnyGroup = ["group", "group2"];

Assert.True(rf.Validate(room));

rf.HasAnyGroup = [];

}

[Fact]

public void TestMarker()

{

var marker = new Marker()

{

Key = "key1",

Value = "value1",

Group = "group1",

Desc = "desc1",

Message = "message1",

};

Assert.True(marker.Filter(FilterHelper.ParseKeyword("key")));

Assert.False(marker.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("key=key1")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("value")));

Assert.False(marker.Filter(FilterHelper.ParseKeyword("value=value")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("value=value1")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("group")));

Assert.False(marker.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("group=group1")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("desc")));

Assert.False(marker.Filter(FilterHelper.ParseKeyword("desc=desc")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("desc=desc1")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("message")));

Assert.False(marker.Filter(FilterHelper.ParseKeyword("message=message")));

Assert.True(marker.Filter(FilterHelper.ParseKeyword("message=message1")));

Assert.False(marker.Filter(FilterHelper.ParseKeyword("notfound")));

Marker marker2;

marker2 = marker.Clone();

Assert.True(marker2.Validated());

marker2.Key = "";

Assert.False(marker2.Validated());

Assert.False(marker.Equal(marker2));

marker2 = marker.Clone();

marker2.Value = "";

Assert.False(marker2.Validated());

Assert.False(marker.Equal(marker2));

marker2 = marker.Clone();

Assert.True(marker.Equal(marker2));

marker2 = marker.Clone();

marker2.Group = "";

Assert.True(marker2.Validated());

Assert.False(marker.Equal(marker2));

marker2 = marker.Clone();

marker2.Desc = "";

Assert.True(marker2.Validated());

Assert.False(marker.Equal(marker2));

marker2 = marker.Clone();

marker2.Message = "";

Assert.True(marker2.Validated());

Assert.False(marker.Equal(marker2));

}

[Fact]

public void TestRoute()

{

var route = new Route()

{

Key = "key1",

Rooms = ["rid1a", "rid1b"],

Desc = "desc1",

Group = "group1",

Message = "message1",

};

Assert.Equal("rid1a\nrid1b", route.RoomsList);

Assert.True(route.Filter(FilterHelper.ParseKeyword("key")));

Assert.False(route.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("key=key1")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("rid1")));

Assert.False(route.Filter(FilterHelper.ParseKeyword("to=rid")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("to=rid1a")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("desc")));

Assert.False(route.Filter(FilterHelper.ParseKeyword("desc=desc")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("desc=desc1")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("group")));

Assert.False(route.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("group=group1")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("message")));

Assert.False(route.Filter(FilterHelper.ParseKeyword("message=message")));

Assert.True(route.Filter(FilterHelper.ParseKeyword("message=message1")));

Assert.False(route.Filter(FilterHelper.ParseKeyword("NotFound")));

Assert.Equal("rid1a;rid1b", route.AllRooms);

Assert.Equal(2, route.RoomsCount);

Route route2;

route2 = route.Clone();

Assert.True(route2.Validated());

Assert.True(route.Equal(route2));

route2.Key = "";

Assert.False(route2.Validated());

Assert.False(route.Equal(route2));

route2 = route.Clone();

route2.Rooms[0] = "rid0";

Assert.True(route2.Validated());

Assert.False(route.Equal(route2));

route2 = route.Clone();

route2.Rooms.Add("rid3");

Assert.True(route2.Validated());

Assert.False(route.Equal(route2));

route2 = route.Clone();

route2.Group = "";

Assert.True(route2.Validated());

Assert.False(route.Equal(route2));

route2 = route.Clone();

route2.Desc = "";

Assert.True(route2.Validated());

Assert.False(route.Equal(route2));

route2 = route.Clone();

route2.Message = "";

Assert.True(route2.Validated());

Assert.False(route.Equal(route2));

}

[Fact]

public void TestTrace()

{

var trace = new Trace()

{

Key = "key1",

Locations = ["rid1", "rid2"],

Group = "group1",

Desc = "desc1",

Message = "message1",

};

Assert.Equal("rid1\nrid2", trace.LocationList);

Assert.True(trace.Filter(FilterHelper.ParseKeyword("key")));

Assert.False(trace.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("key=key1")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("rid")));

Assert.False(trace.Filter(FilterHelper.ParseKeyword("to=rid")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("to=rid1")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("desc")));

Assert.False(trace.Filter(FilterHelper.ParseKeyword("desc=desc")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("desc=desc1")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("group")));

Assert.False(trace.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("group=group1")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("message")));

Assert.False(trace.Filter(FilterHelper.ParseKeyword("message=message")));

Assert.True(trace.Filter(FilterHelper.ParseKeyword("message=message1")));

Assert.False(trace.Filter(FilterHelper.ParseKeyword("NotFound")));

Assert.Equal(2, trace.LocationsCount);

Trace trace2;

trace2 = trace.Clone();

Assert.True(trace.Equal(trace2));

Assert.True(trace2.Validated());

trace2.Key = "";

Assert.False(trace.Equal(trace2));

Assert.False(trace2.Validated());

trace2 = trace.Clone();

trace2.Locations[0] = "rid0";

Assert.False(trace.Equal(trace2));

Assert.True(trace2.Validated());

trace2 = trace.Clone();

trace2.Locations.Add("rid3");

Assert.False(trace.Equal(trace2));

Assert.True(trace2.Validated());

trace2 = trace.Clone();

trace2.Group = "";

Assert.False(trace.Equal(trace2));

Assert.True(trace2.Validated());

trace2 = trace.Clone();

trace2.Desc = "";

Assert.False(trace.Equal(trace2));

Assert.True(trace2.Validated());

trace2 = trace.Clone();

trace2.Message = "";

Assert.False(trace.Equal(trace2));

Assert.True(trace2.Validated());

}

[Fact]

public void TestRegion()

{

var region = new Region()

{

Key = "key1",

Group = "group1",

Desc = "desc1",

Message = "message1",

Items = [new RegionItem(RegionItemType.Room, "room1", false), new RegionItem(RegionItemType.Zone, "zone1", true)]

};

Assert.True(region.Filter(FilterHelper.ParseKeyword("key")));

Assert.False(region.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("key=key1")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("room")));

Assert.False(region.Filter(FilterHelper.ParseKeyword("to=room")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("to=room1")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("zone")));

Assert.False(region.Filter(FilterHelper.ParseKeyword("to=zone")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("to=zone1")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("desc")));

Assert.False(region.Filter(FilterHelper.ParseKeyword("desc=desc")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("desc=desc1")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("group")));

Assert.False(region.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("group=group1")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("message")));

Assert.False(region.Filter(FilterHelper.ParseKeyword("message=message")));

Assert.True(region.Filter(FilterHelper.ParseKeyword("message=message1")));

Assert.False(region.Filter(FilterHelper.ParseKeyword("NotFound")));

Assert.Equal(2, region.ItemsCount);

Region region2;

region2 = region.Clone();

Assert.True(region.Equal(region2));

Assert.True(region2.Validated());

region2.Key = "";

Assert.False(region.Equal(region2));

Assert.False(region2.Validated());

region2 = region.Clone();

region2.Items[0].Value = "room0";

Assert.False(region.Equal(region2));

Assert.True(region2.Validated());

region2 = region.Clone();

region2.Items.Add(new RegionItem(RegionItemType.Room, "room3", false));

Assert.False(region.Equal(region2));

Assert.True(region2.Validated());

region2 = region.Clone();

region2.Group = "";

Assert.False(region.Equal(region2));

Assert.True(region2.Validated());

region2 = region.Clone();

region2.Desc = "";

Assert.False(region.Equal(region2));

Assert.True(region2.Validated());

region2 = region.Clone();

region2.Message = "";

Assert.False(region.Equal(region2));

Assert.True(region2.Validated());

}

[Fact]

public void TestRegionItem()

{

var ri = new RegionItem(RegionItemType.Room, "room1", false);

RegionItem ri2;

Assert.True(ri.Validated());

Assert.True(ri.IsRoom);

Assert.Equal("+", ri.ExcludeLabel);

Assert.Equal("加入房间 room1", ri.Label);

ri2 = ri.Clone();

Assert.True(ri.Equal(ri2));

Assert.True(ri2.Validated());

ri2 = ri.Clone();

ri2.Value = "";

Assert.False(ri.Equal(ri2));

Assert.False(ri2.Validated());

ri2 = ri.Clone();

ri2.Type = RegionItemType.Zone;

Assert.False(ri.Equal(ri2));

Assert.True(ri2.Validated());

Assert.False(ri2.IsRoom);

Assert.Equal("+", ri2.ExcludeLabel);

Assert.Equal("加入区域 room1", ri2.Label);

ri2 = ri.Clone();

ri2.Not = true;

Assert.False(ri.Equal(ri2));

Assert.True(ri2.Validated());

Assert.Equal("-", ri2.ExcludeLabel);

Assert.Equal("排除房间 room1", ri2.Label);

ri2 = ri.Clone();

ri2.Not = true;

ri2.Type = RegionItemType.Zone;

Assert.False(ri.Equal(ri2));

Assert.True(ri2.Validated());

Assert.Equal("-", ri2.ExcludeLabel);

Assert.Equal("排除区域 room1", ri2.Label);

}

[Fact]

public void TestLandmark()

{

var lm = new Landmark()

{

Key = "key1",

Type = "type1",

Value = "value1",

Group = "group1",

Desc = "desc1"

};

Assert.True(lm.Filter(FilterHelper.ParseKeyword("key")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("key=key1")));

Assert.False(lm.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("type")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("type=type1")));

Assert.False(lm.Filter(FilterHelper.ParseKeyword("type=type")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("value")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("value=value1")));

Assert.False(lm.Filter(FilterHelper.ParseKeyword("value=value")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("group")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("group=group1")));

Assert.False(lm.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("desc")));

Assert.True(lm.Filter(FilterHelper.ParseKeyword("desc=desc1")));

Assert.False(lm.Filter(FilterHelper.ParseKeyword("desc=desc")));

Assert.False(lm.Filter(FilterHelper.ParseKeyword("NotFound")));

Landmark lm2;

lm2 = lm.Clone();

Assert.True(lm.Equal(lm2));

Assert.True(lm2.Validated());

Assert.Equal(lm.UniqueKey().ToString(), lm2.UniqueKey().ToString());

lm2.Key = "";

Assert.False(lm.Equal(lm2));

Assert.False(lm2.Validated());

Assert.NotEqual(lm.UniqueKey, lm2.UniqueKey);

lm2 = lm.Clone();

lm2.Type = "";

Assert.False(lm.Equal(lm2));

Assert.True(lm2.Validated());

Assert.NotEqual(lm.UniqueKey, lm2.UniqueKey);

lm2 = lm.Clone();

lm2.Value = "";

Assert.False(lm.Equal(lm2));

Assert.True(lm2.Validated());

Assert.Equal(lm.UniqueKey().ToString(), lm2.UniqueKey().ToString());

lm2 = lm.Clone();

lm2.Group = "";

Assert.False(lm.Equal(lm2));

Assert.True(lm2.Validated());

Assert.Equal(lm.UniqueKey().ToString(), lm2.UniqueKey().ToString());

lm2 = lm.Clone();

lm2.Desc = "";

Assert.False(lm.Equal(lm2));

Assert.True(lm2.Validated());

Assert.Equal(lm.UniqueKey().ToString(), lm2.UniqueKey().ToString());

}

[Fact]

public void TestShortcut()

{

var sc = new Shortcut()

{

Key = "key1",

Group = "group1",

Desc = "desc1",

Command = "command1",

To = "to1",

Cost = 2,

RoomConditions = [new ValueCondition("con1", 1, false), new ValueCondition("con2", 1, true)],

Conditions = [new ValueCondition("con3", 1, false), new ValueCondition("con4", 1, true)]

};

Assert.True(sc.Filter(FilterHelper.ParseKeyword("key")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("key=key1")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("command")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("command=command1")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("command=command")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("to")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("to=to1")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("to=to")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("group")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("group=group1")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("desc")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("desc=desc1")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("desc=desc")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("on1")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("tag=con1")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("tag=con")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("on3")));

Assert.True(sc.Filter(FilterHelper.ParseKeyword("tag=con3")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("tag=con")));

Assert.False(sc.Filter(FilterHelper.ParseKeyword("NotFound")));

Shortcut sc2;

sc2 = sc.Clone();

Assert.True(sc.Equal(sc2));

Assert.True(sc2.Validated());

sc2.Key = "";

Assert.False(sc.Equal(sc2));

Assert.False(sc2.Validated());

sc2 = sc.Clone();

sc2.Command = "";

Assert.False(sc.Equal(sc2));

Assert.False(sc2.Validated());

sc2 = sc.Clone();

sc2.To = "";

Assert.False(sc.Equal(sc2));

Assert.True(sc2.Validated());

sc2 = sc.Clone();

sc2.Cost = -1;

Assert.False(sc.Equal(sc2));

Assert.True(sc2.Validated());

sc2 = sc.Clone();

sc2.Conditions[0].Key = "wrongkey";

Assert.False(sc.Equal(sc2));

Assert.True(sc2.Validated());

sc2 = sc.Clone();

sc2.Conditions.Add(new("con5", 0, true));

Assert.False(sc.Equal(sc2));

Assert.True(sc2.Validated());

sc2 = sc.Clone();

Assert.True(sc2.HasCondition);

Assert.Equal("con3,! con4", sc2.AllConditions);

sc2 = sc.Clone();

sc2.Conditions = [];

Assert.False(sc2.HasCondition);

Assert.Equal("", sc2.AllConditions);

sc2 = sc.Clone();

sc2.RoomConditions[0].Key = "wrongkey";

Assert.False(sc.Equal(sc2));

Assert.True(sc2.Validated());

sc2 = sc.Clone();

sc2.RoomConditions.Add(new("con5", 0, true));

Assert.False(sc.Equal(sc2));

Assert.True(sc2.Validated());

}

[Fact]

public void TestVariable()

{

var var1 = new Variable()

{

Key = "key1",

Value = "value1",

Group = "group1",

Desc = "desc1"

};

Assert.True(var1.Filter(FilterHelper.ParseKeyword("key")));

Assert.True(var1.Filter(FilterHelper.ParseKeyword("key=key1")));

Assert.False(var1.Filter(FilterHelper.ParseKeyword("key=key")));

Assert.True(var1.Filter(FilterHelper.ParseKeyword("value")));

Assert.True(var1.Filter(FilterHelper.ParseKeyword("value=value1")));

Assert.False(var1.Filter(FilterHelper.ParseKeyword("value=value")));

Assert.True(var1.Filter(FilterHelper.ParseKeyword("group")));

Assert.True(var1.Filter(FilterHelper.ParseKeyword("group=group1")));

Assert.False(var1.Filter(FilterHelper.ParseKeyword("group=group")));

Assert.True(var1.Filter(FilterHelper.ParseKeyword("desc")));

Assert.True(var1.Filter(FilterHelper.ParseKeyword("desc=desc1")));

Assert.False(var1.Filter(FilterHelper.ParseKeyword("desc=desc")));

Assert.False(var1.Filter(FilterHelper.ParseKeyword("NotFound")));

Variable var2;

var2 = var1.Clone();

Assert.True(var1.Equal(var2));

Assert.True(var2.Validated());

var2.Key = "";

Assert.False(var1.Equal(var2));

Assert.False(var2.Validated());

var2 = var1.Clone();

var2.Value = "";

Assert.False(var1.Equal(var2));

Assert.True(var2.Validated());

var2 = var1.Clone();

var2.Group = "";

Assert.False(var1.Equal(var2));