public void DetectMinimumCircularDependencyBetweenTwoNodes()
{
var a = new Node {
Name = "A"
};
var b = new Node {
Name = "B"
};
a.Edges.Add(b);
b.Edges.Add(a);
var roots = new Roots();
roots.Entangle(a);
var serializers = new Serializers(new SerializerFactory());
var stateMaps = new StateMaps(serializers);
var persister = new Persister(new InMemoryStorageEngine(), roots, serializers, stateMaps);
persister.DetectSerializeAndPersistChanges();
var circularChain = CircularDependencyDetector.Check(serializers[0], stateMaps, serializers);
circularChain.IsCircular.ShouldBeTrue();
circularChain.Path.Count().ShouldBe(3);
circularChain.ToString().ShouldBe("A->B->A");
}
public void DetectCircularDependencyInComplexGraph()
{
var a = new Node {
Name = "A"
};
var b = new Node {
Name = "B"
};
var c = new Node {
Name = "C"
};
var d = new Node {
Name = "D"
};
var e = new Node {
Name = "E"
};
var f = new Node {
Name = "F"
};
var g = new Node {
Name = "G"
};
var h = new Node {
Name = "H"
};
a.Add(b);
a.Add(c);
c.Add(g);
c.Add(f);
g.Add(b);
b.Add(d);
d.Add(h);
d.Add(f);
f.Add(e);
e.Add(d);
var roots = new Roots();
roots.Entangle(a);
var serializers = new Serializers(new SerializerFactory());
var stateMaps = new StateMaps(serializers);
var persister = new Persister(new InMemoryStorageEngine(), roots, serializers, stateMaps);
persister.DetectSerializeAndPersistChanges();
var circularChain = CircularDependencyDetector.Check(serializers[0], stateMaps, serializers);
circularChain.IsCircular.ShouldBe(true);
circularChain.Path.Count().ShouldBe(4);
circularChain.ToString().ShouldBe("F->E->D->F");
}
//Used when data exists
private ObjectStore(
Roots roots,
StateMaps stateMaps, Serializers serializers,
IStorageEngine storageEngine)
{
Roots = roots;
StorageEngine = storageEngine;
_persister = new Persister(StorageEngine, roots, serializers, stateMaps);
}
//Used when data does not already exists
private ObjectStore(IStorageEngine storageEngine)
{
StorageEngine = storageEngine;
var roots = new Roots();
var serializers = new Serializers(new SerializerFactory());
var stateMaps = new StateMaps(serializers);
Roots = roots;
_persister = new Persister(StorageEngine, roots, serializers, stateMaps);
}
public Persister(
IStorageEngine storageEngine,
Roots roots,
Serializers.Serializers serializers,
StateMaps stateMaps)
{
_storageEngine = storageEngine;
_roots = roots;
_serializers = serializers;
_stateMaps = stateMaps;
_maxObjectId = serializers.NextObjectId - 1;
}
public void CaseA()
{
var report = new TestReport();
var sample = new[]
{
"#############",
"#a ### b##",
"# A###### ##",
"# ######B ##",
"######### ##",
"#############"
};
var boundry = Bitmap.Create(sample, x => x == '#'); //sample.ToMap('#', 'A', 'B');
var staticMaps = new StaticMaps(
Bitmap.Create(sample, '#'),
Bitmap.Create(sample, ' ', 'a', 'b'),
null,
null
);
var stateMaps = new StateMaps(
Bitmap.Create(sample, 'A', 'B'),
FloodFill.Fill(staticMaps.WallMap, Bitmap.FindPosition(sample, 'a')));
var pushMap = PushMap.Find(staticMaps, stateMaps, Bitmap.FindPosition(sample, 'A'),
Bitmap.FindPosition(sample, 'b'));
report.WriteLine(pushMap);
Assert.Equal(new TestReport(@".............
..X..........
.............
..X..........
.............
............."), report);
}
public void DetectCircularDependencyOneNodeHavingMultipleOutgoingEdges()
{
var a = new Node {
Name = "A"
};
var b = new Node {
Name = "B"
};
var c = new Node {
Name = "C"
};
var d = new Node {
Name = "D"
};
a.Edges.Add(b);
a.Edges.Add(d);
b.Edges.Add(c);
c.Edges.Add(b);
var roots = new Roots();
roots.Entangle(a);
var serializers = new Serializers(new SerializerFactory());
var stateMaps = new StateMaps(serializers);
var persister = new Persister(new InMemoryStorageEngine(), roots, serializers, stateMaps);
persister.DetectSerializeAndPersistChanges();
var circularChain = CircularDependencyDetector.Check(serializers[0], stateMaps, serializers);
circularChain.IsCircular.ShouldBeTrue();
circularChain.Path.Count().ShouldBe(3);
circularChain.ToString().ShouldBe("B->C->B");
}
public void DynamicDeadMap()
{
// Init
var p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#...XX...#",
"#...X#...#",
"#.P......#",
"##########"
});
var stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#...#X...#",
"#...X#...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#...##...#",
"#...XX...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#........#",
"#...XX...#",
"#...##...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#........#",
"#...XX...#",
"#...X#...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#........#",
"#...$$...#",
"#...X#...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#........#",
"#...$$...#",
"#...#X...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#........#",
"#...#X...#",
"#...$$...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.True(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
// NOT_DEAD
p = Puzzle.Builder.FromLines(
new[]
{
"##########",
"#........#",
"#...$$...#",
"#...$#...#",
"#.P......#",
"##########"
});
stat = new StaticAnalysisMaps(p);
Assert.False(DeadMapAnalysis.DynamicCheck(stat, StateMaps.Create(p)));
}
public static State Load(IStorageEngine storageEngine, ISet <object> ephemeralInstances)
{
var valuesDictionaries = new DictionaryWithDefault <long, Dictionary <string, object> >(_ => new Dictionary <string, object>());
//Load all entries from log file
var storedState = storageEngine.Load();
var serializers = new Serializers(new SerializerFactory());
var stateMaps = new StateMaps(serializers);
var entriesPerOwner = storedState.StorageEntries;
//var entriesPerOwner = storedState.StorageEntries;
var serializersTypeEntries = storedState.Serializers;
var toDeserialize = new Queue <long>();
var referenced = new DictionaryWithDefault <long, List <Reference> >(_ => new List <Reference>());
ISerializer Deserialize(long id)
{
if (serializers.ContainsKey(id))
{
return(serializers[id]);
}
var ownerEntries = entriesPerOwner.ContainsKey(id)
? entriesPerOwner[id]
: Enumerable.Empty <StorageEntry>();
var resolvedValues = valuesDictionaries[id];
//deserialize non-referencing values
var resolvableEntries = ownerEntries
.Where(e => !e.Reference.HasValue)
.ToList();
foreach (var resolvableEntry in resolvableEntries)
{
resolvedValues[resolvableEntry.Key] = resolvableEntry.Value;
}
var referencedEntries = ownerEntries.Where(e => e.Reference.HasValue);
foreach (var referencedEntry in referencedEntries)
{
// ReSharper disable once PossibleInvalidOperationException
var wp = Deserialize(referencedEntry.Reference.Value);
resolvedValues[referencedEntry.Key] = wp.Instance;
}
var serializer = (ISerializer)DeserializationMethodInvoker
.Invoke(
id,
serializersTypeEntries[id],
valuesDictionaries[id],
ephemeralInstances
);
stateMaps[id] = new StateMap(serializers, resolvedValues);
serializers.Add(serializer);
if (serializer.Instance is Reference r && r.Id.HasValue)
{
toDeserialize.Enqueue(r.Id.Value);
referenced[r.Id.Value].Add(r);
}
return(serializer);
}
var roots = (Roots)Deserialize(0).Instance;
ephemeralInstances.Add(roots);
while (toDeserialize.Any())
{
Deserialize(toDeserialize.Dequeue());
}
foreach (var serializer in serializers)
{
foreach (var reference in referenced[serializer.Id])
{
reference.SetSerializer(serializer);
}
}
return(new State(roots, stateMaps, serializers));
}
public record State(Roots Roots, StateMaps StateMaps, Serializers Serializers)
{
}
