Rick-van-Dam · Rick-van-Dam · Oct 20, 2018 · Jul 18, 2018 · Oct 20, 2018
diff --git a/Duality/Source/Code/Singularity.Duality/Singularity.Duality.csproj b/Duality/Source/Code/Singularity.Duality/Singularity.Duality.csproj
@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netstandard1.1</TargetFramework>
+    <PackageTargetFallback>$(PackageTargetFallback);net00</PackageTargetFallback>
     <AssemblyName>Singularity.Duality.core</AssemblyName>
     <PackageLicenseUrl>https://github.com/Barsonax/Singularity/blob/master/LICENSE</PackageLicenseUrl>
     <PackageProjectUrl>https://github.com/Barsonax/Singularity</PackageProjectUrl>

diff --git a/Singularity.Test/ContainerTests.cs b/Singularity.Test/ContainerTests.cs
@@ -355,7 +355,30 @@ public class Flat
         {
             public class Exceptions
             {
-                [Fact]
+	            [Fact]
+	            public void GetInstance_MissingDecoratorDependency_Throws()
+	            {
+		            try
+		            {
+			            var config = new BindingConfig();
+			            config.For<ITestService10>().Inject<TestService10>();
+			            config.Decorate<ITestService10>().With<TestService10_Decorator1>();
+			            var container = new Container(config);
+					}
+		            catch (AggregateException e)
+		            {
+			            Assert.Equal(typeof(SingularityAggregateException), e.GetType());
+			            var aggregateException = e.Flatten();
+
+			            Assert.Equal(1, aggregateException.InnerExceptions.Count);
+			            Assert.Equal(typeof(DependencyNotFoundException), aggregateException.InnerExceptions[0].GetType());
+			            var dependencyNotFoundException = (DependencyNotFoundException)aggregateException.InnerExceptions[0];
+
+			            Assert.Equal(typeof(int), dependencyNotFoundException.Type);
+					}
+				}
+
+				[Fact]
                 public void GetInstance_MissingDependency_Throws()
                 {
                     var container = new Container(new BindingConfig());

diff --git a/Singularity.Test/Exceptions/SingularityAggregrateExceptionTests.cs b/Singularity.Test/Exceptions/SingularityAggregrateExceptionTests.cs
@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Singularity.Test.Exceptions
+{
+    public class SingularityAggregrateExceptionTests
+    {
+		[Fact]
+	    public void FirstLevel_IsCorrect()
+	    {
+			var exception = new SingularityAggregateException("1", new List<Exception>());
+
+		    var lines = exception.Message.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			Assert.Equal("1",lines[0]);
+		}
+
+	    [Fact]
+	    public void SecondLevel_IsCorrect()
+	    {
+
+		    var exception = new SingularityAggregateException("1", new List<Exception>
+		    {
+			    new SingularityAggregateException("21", new List<Exception>
+			    {
+				    new Exception("211"),
+				    new Exception("212"),
+				    new Exception("213"),
+			    }),
+			    new SingularityAggregateException("22", new List<Exception>
+			    {
+				    new Exception("221"),
+				    new Exception("222"),
+				    new Exception("223"),
+			    })
+		    });
+
+		    var lines = exception.Message.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
+		    Assert.Equal("1", lines[0]);
+
+		    Assert.Equal("	21", lines[1]);
+		    Assert.Equal("		211", lines[2]);
+		    Assert.Equal("		212", lines[3]);
+		    Assert.Equal("		213", lines[4]);
+
+		    Assert.Equal("	22", lines[5]);
+		    Assert.Equal("		221", lines[6]);
+		    Assert.Equal("		222", lines[7]);
+		    Assert.Equal("		223", lines[8]);
+	    }
+
+	    [Fact]
+	    public void ThirdLevel_IsCorrect()
+	    {
+
+		    var exception = new SingularityAggregateException("1", new List<Exception>
+		    {
+			    new SingularityAggregateException("21", new List<Exception>
+			    {
+				    new Exception("211"),
+				    new Exception("212"),
+				    new Exception("213"),
+			    }),
+			    new SingularityAggregateException("22", new List<Exception>
+			    {
+				    new Exception("221"),
+				    new Exception("222"),
+				    new Exception("223"),
+			    })
+		    });
+
+		    var lines = exception.Message.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
+		    Assert.Equal("1", lines[0]);
+
+		    Assert.Equal("	21", lines[1]);
+		    Assert.Equal("		211", lines[2]);
+		    Assert.Equal("		212", lines[3]);
+		    Assert.Equal("		213", lines[4]);
+
+		    Assert.Equal("	22", lines[5]);
+		    Assert.Equal("		221", lines[6]);
+		    Assert.Equal("		222", lines[7]);
+		    Assert.Equal("		223", lines[8]);
+	    }
+
+	    [Fact]
+	    public void ThirdLevel_Mixed_IsCorrect()
+	    {
+
+		    var exception = new SingularityAggregateException("1", new List<Exception>
+		    {
+			    new SingularityAggregateException("21", new List<Exception>
+			    {
+				    new Exception("211"),
+				    new Exception("212"),
+				    new Exception("213"),
+			    }),
+			    new SingularityAggregateException("22", new List<Exception>
+			    {
+				    new Exception("221"),
+				    new Exception("222"),
+				    new Exception("223"),
+			    }),
+				new Exception("23"),
+			    new Exception("24"),
+			    new Exception("25")
+			});
+
+		    var lines = exception.Message.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
+		    Assert.Equal("1", lines[0]);
+
+		    Assert.Equal("	21", lines[1]);
+		    Assert.Equal("		211", lines[2]);
+		    Assert.Equal("		212", lines[3]);
+		    Assert.Equal("		213", lines[4]);
+
+		    Assert.Equal("	22", lines[5]);
+		    Assert.Equal("		221", lines[6]);
+		    Assert.Equal("		222", lines[7]);
+		    Assert.Equal("		223", lines[8]);
+
+		    Assert.Equal("	23", lines[9]);
+		    Assert.Equal("	24", lines[10]);
+		    Assert.Equal("	25", lines[11]);
+		}
+	}
+}
diff --git a/Singularity.Test/Graph/DependencyGraphTests.cs b/Singularity.Test/Graph/DependencyGraphTests.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using Singularity.Bindings;
+using Singularity.Graph;
+using Singularity.Test.TestClasses;
+using Xunit;
+
+namespace Singularity.Test.Graph
+{
+    public class DependencyGraphTests
+    {
+		[Fact]
+	    public void Constructor_CorruptLifetimeValue_Throws()
+		{
+			var config = new BindingConfig();
+			config.For<ITestService10>().Inject<TestService10>().With((Lifetime)(-234324524));
+
+			Assert.Throws<ArgumentOutOfRangeException>(() =>
+			{
+				var dependencyGraph = new DependencyGraph(config, new List<IDependencyExpressionGenerator>());
+			});		
+		}
+    }
+}
diff --git a/Singularity.Test/TestClasses/TestDecoratorClasses.cs b/Singularity.Test/TestClasses/TestDecoratorClasses.cs
@@ -44,7 +44,17 @@ public class Component : IComponent { }
 
 	public interface IComponent { }
 
-    public class TestService11_Decorator1 : ITestService11
+	public class TestService10_Decorator1 : ITestService10
+	{
+		public ITestService10 TestService10 { get; }
+
+		public TestService10_Decorator1(ITestService10 testService10, int dummyValue)
+		{
+			TestService10 = testService10;
+		}
+	}
+
+	public class TestService11_Decorator1 : ITestService11
     {
         public ITestService10 TestService10 => TestService11.TestService10;
         public ITestService11 TestService11 { get; }

diff --git a/Singularity/Exceptions/SingularityAggregateException.cs b/Singularity/Exceptions/SingularityAggregateException.cs
@@ -1,17 +1,49 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 
 namespace Singularity
 {
 	public class SingularityAggregateException : AggregateException
 	{
 		public string HeaderMessage { get; }
-		public override string Message => $"{HeaderMessage}:{Environment.NewLine}{string.Join(Environment.NewLine, InnerExceptions.Select(x => x.Message))}";
+		public override string Message => GenerateString(new StringBuilder(), 0, this).ToString();
+
+		private static StringBuilder GenerateString(StringBuilder builder, int indentLevel, AggregateException exception)
+		{
+			if (exception is SingularityAggregateException singularityAggregateException)
+			{
+				builder.Append(new string('	', indentLevel));
+				builder.AppendLine(singularityAggregateException.HeaderMessage);
+			}
+			indentLevel++;
+			foreach (var innerException in exception.InnerExceptions)
+			{
+
+
+				if (innerException is AggregateException aggregateException)
+				{
+					GenerateString(builder, indentLevel, aggregateException);
+				}
+				else
+				{					
+					foreach (var line in innerException.Message.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))
+					{
+						builder.Append(new string('	', indentLevel));
+						builder.AppendLine(line);
+					}					
+				}
+			}
+
+			return builder;
+		}
 
 		public SingularityAggregateException(string message, IEnumerable<Exception> innerExceptions) : base(innerExceptions)
 		{
 			HeaderMessage = message;
+
+
 		}
 	}
 }
diff --git a/Singularity/Singularity.csproj b/Singularity/Singularity.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netstandard1.1</TargetFramework>
     <Version>0.0.1</Version>
     <Authors>Barsonax</Authors>
     <Description>The core library for the singularity ioc container</Description>