From 49aff8a483d423391919f3393b484ed552403d78 Mon Sep 17 00:00:00 2001
From: Sergey Penkovsky <sergey.penkovsky@gmail.com>
Date: Fri, 3 Jul 2020 09:31:35 +0300
Subject: [PATCH] implemented toFactory5 method

---
 lib/resolvers/resolving_context.dart |  9 +++++--
 test/di_container_test.dart          | 37 ++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/lib/resolvers/resolving_context.dart b/lib/resolvers/resolving_context.dart
index 6277481..60fd9fa 100644
--- a/lib/resolvers/resolving_context.dart
+++ b/lib/resolvers/resolving_context.dart
@@ -104,8 +104,13 @@ class ResolvingContext<T> extends Resolver {
      */
   ResolvingContext<T> toFactory5<T1, T2, T3, T4, T5>(
       T Function(T1, T2, T3, T4, T5) factory) {
-    // TODO: implement toFactory5
-    throw UnimplementedError();
+    Resolver<T> resolver = FactoryResolver<T>(() => factory(
+        _container.resolve<T1>(),
+        _container.resolve<T2>(),
+        _container.resolve<T3>(),
+        _container.resolve<T4>(),
+        _container.resolve<T5>()));
+    return toResolver(resolver);
   }
 
   /**
diff --git a/test/di_container_test.dart b/test/di_container_test.dart
index bdf00a2..054cd43 100644
--- a/test/di_container_test.dart
+++ b/test/di_container_test.dart
@@ -198,6 +198,28 @@ void main() {
     expect(container.resolve<DependOnABCD>().c, c);
     expect(container.resolve<DependOnABCD>().d, d);
   });
+
+  test("Bind to the factory resolves with 5 value", () {
+    final container = DiContainer();
+    final a = AA();
+    final b = BB();
+    final c = CC();
+    final d = DD();
+    final e = EE();
+    container.bind<A>().toValue(a);
+    container.bind<B>().toValue(b);
+    container.bind<C>().toValue(c);
+    container.bind<D>().toValue(d);
+    container.bind<E>().toValue(e);
+    container.bind<DependOnABCDE>().toFactory5<A, B, C, D, E>(
+        (a, b, c, d, e) => DependOnABCDE(a, b, c, d, e));
+
+    expect(container.resolve<DependOnABCDE>().a, a);
+    expect(container.resolve<DependOnABCDE>().b, b);
+    expect(container.resolve<DependOnABCDE>().c, c);
+    expect(container.resolve<DependOnABCDE>().d, d);
+    expect(container.resolve<DependOnABCDE>().e, e);
+  });
 }
 
 ResolverMock<T> _makeResolver<T>(T expectedValue) {
@@ -224,6 +246,10 @@ abstract class D {}
 
 class DD implements D {}
 
+abstract class E {}
+
+class EE implements E {}
+
 class DependOnA {
   final A a;
 
@@ -255,3 +281,14 @@ class DependOnABCD {
   DependOnABCD(this.a, this.b, this.c, this.d)
       : assert(a != null && b != null && c != null && d != null);
 }
+
+class DependOnABCDE {
+  final A a;
+  final B b;
+  final C c;
+  final D d;
+  final E e;
+
+  DependOnABCDE(this.a, this.b, this.c, this.d, this.e)
+      : assert(a != null && b != null && c != null && d != null && e != null);
+}