| #!/usr/bin/env python3 |
| # Copyright 2016 Google Inc. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS-IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| import pytest |
| |
| from fruit_test_common import * |
| from fruit_test_config import CXX_COMPILER_NAME |
| |
| COMMON_DEFINITIONS = ''' |
| #include "test_common.h" |
| |
| struct Scaler; |
| struct ScalerImpl; |
| |
| struct Annotation1 {}; |
| using ScalerAnnot1 = fruit::Annotated<Annotation1, Scaler>; |
| using ScalerImplAnnot1 = fruit::Annotated<Annotation1, ScalerImpl>; |
| |
| struct Annotation2 {}; |
| using ScalerAnnot2 = fruit::Annotated<Annotation2, Scaler>; |
| using ScalerImplAnnot2 = fruit::Annotated<Annotation2, ScalerImpl>; |
| |
| template <typename T> |
| using WithNoAnnotation = T; |
| |
| template <typename T> |
| using WithAnnotation1 = fruit::Annotated<Annotation1, T>; |
| ''' |
| |
| @pytest.mark.parametrize('XFactoryAnnot', [ |
| 'std::function<X()>', |
| 'fruit::Annotated<Annotation1, std::function<X()>>', |
| ]) |
| def test_register_factory_success_no_params_autoinject(XFactoryAnnot): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| fruit::Component<XFactoryAnnot> getComponent() { |
| return fruit::createComponent(); |
| } |
| |
| int main() { |
| fruit::Injector<XFactoryAnnot> injector(getComponent); |
| injector.get<XFactoryAnnot>()(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ConstructX,XPtrAnnot,XPtrFactoryAnnot', [ |
| ('X()', 'X', 'std::function<X()>'), |
| ('X()', 'fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, std::function<X()>>'), |
| ('std::unique_ptr<X>()', 'std::unique_ptr<X>', 'std::function<std::unique_ptr<X>()>'), |
| ('std::unique_ptr<X>()', 'fruit::Annotated<Annotation1, std::unique_ptr<X>>', 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<X>()>>'), |
| ]) |
| def test_register_factory_success_no_params(ConstructX, XPtrAnnot, XPtrFactoryAnnot): |
| source = ''' |
| struct X {}; |
| |
| fruit::Component<XPtrFactoryAnnot> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<XPtrAnnot()>([](){return ConstructX;}); |
| } |
| |
| int main() { |
| fruit::Injector<XPtrFactoryAnnot> injector(getComponent); |
| injector.get<XPtrFactoryAnnot>()(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('MaybeConst', [ |
| '', |
| 'const', |
| ]) |
| def test_register_factory_autoinject_success(MaybeConst): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| INJECT(ScalerImpl(ASSISTED(double) factor)) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<MaybeConst ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImpl>(); |
| } |
| |
| int main() { |
| fruit::Injector<MaybeConst ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_autoinject_abstract_class_with_no_virtual_destructor_error(): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| public: |
| INJECT(ScalerImpl(ASSISTED(double))) { |
| } |
| |
| double scale(double x) override { |
| return x; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImpl>(); |
| } |
| ''' |
| expect_compile_error( |
| 'FactoryBindingForUniquePtrOfClassWithNoVirtualDestructorError<std::function<std::unique_ptr<Scaler(,std::default_delete<Scaler>)?>\(double\)>,std::function<std::unique_ptr<ScalerImpl(,std::default_delete<ScalerImpl>)?>\(double\)>>', |
| 'Fruit was trying to bind BaseFactory to DerivedFactory but the return type of BaseFactory is a std::unique_ptr of a class with no virtual destructor', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_autoinject_non_abstract_class_with_no_virtual_destructor_error(): |
| source = ''' |
| struct Scaler { |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| public: |
| INJECT(ScalerImpl(ASSISTED(double))) { |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImpl>(); |
| } |
| ''' |
| expect_compile_error( |
| 'FactoryBindingForUniquePtrOfClassWithNoVirtualDestructorError<std::function<std::unique_ptr<Scaler(,std::default_delete<Scaler>)?>\(double\)>,std::function<std::unique_ptr<ScalerImpl(,std::default_delete<ScalerImpl>)?>\(double\)>>', |
| 'Fruit was trying to bind BaseFactory to DerivedFactory but the return type of BaseFactory is a std::unique_ptr of a class with no virtual destructor', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerFactoryAnnot,MaybeConstScalerFactoryAnnot', [ |
| ('Scaler', |
| 'std::function<std::unique_ptr<Scaler>(double)>', |
| 'std::function<std::unique_ptr<Scaler>(double)>'), |
| ('Scaler', |
| 'std::function<std::unique_ptr<Scaler>(double)>', |
| 'const std::function<std::unique_ptr<Scaler>(double)>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation1, const std::function<std::unique_ptr<Scaler>(double)>>'), |
| ]) |
| def test_autoinject(ScalerAnnot, ScalerFactoryAnnot, MaybeConstScalerFactoryAnnot): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| INJECT(ScalerImpl(ASSISTED(double) factor)) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<MaybeConstScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot, ScalerImpl>(); |
| } |
| |
| int main() { |
| fruit::Injector<MaybeConstScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('MaybeConst', [ |
| '', |
| 'const', |
| ]) |
| def test_autoinject_returning_value(MaybeConst): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| INJECT(Scaler(ASSISTED(double) factor, X)) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<MaybeConst ScalerFactory> getScalerComponent() { |
| return fruit::createComponent(); |
| } |
| |
| int main() { |
| fruit::Injector<MaybeConst ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerImplAnnot,ScalerFactoryAnnot,ScalerImplFactoryAnnotRegex', [ |
| ('Scaler', |
| 'ScalerImpl', |
| 'std::function<std::unique_ptr<Scaler>(double)>', |
| 'std::function<std::unique_ptr<ScalerImpl(,std::default_delete<ScalerImpl>)?>\(double\)>', |
| ), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation2,std::function<std::unique_ptr<ScalerImpl(,std::default_delete<ScalerImpl>)?>\(double\)>>', |
| ), |
| ]) |
| def test_autoinject_error_abstract_class(ScalerAnnot, ScalerImplAnnot, ScalerFactoryAnnot, ScalerImplFactoryAnnotRegex): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| // Note: here we "forgot" to implement scale() (on purpose, for this test) so ScalerImpl is an abstract class. |
| }; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot, ScalerImplAnnot>(); |
| } |
| ''' |
| expect_compile_error( |
| 'NoBindingFoundForAbstractClassError<ScalerImplFactoryAnnotRegex,ScalerImpl>', |
| 'No explicit binding was found for T, and note that C is an abstract class', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_autoinject_nonmovable_ok(): |
| source = ''' |
| struct I { |
| virtual ~I() = default; |
| }; |
| |
| struct C : public I { |
| INJECT(C()) = default; |
| |
| C(const C&) = delete; |
| C(C&&) = delete; |
| C& operator=(const C&) = delete; |
| C& operator=(C&&) = delete; |
| }; |
| |
| using IFactory = std::function<std::unique_ptr<I>()>; |
| |
| fruit::Component<IFactory> getIFactory() { |
| return fruit::createComponent() |
| .bind<I, C>(); |
| } |
| |
| int main() { |
| fruit::Injector<IFactory> injector(getIFactory); |
| IFactory iFactory(injector); |
| std::unique_ptr<I> i = iFactory(); |
| (void)i; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_2_assisted_params(): |
| source = ''' |
| struct Foo { |
| Foo(int x, float y) { |
| (void)x; |
| (void)y; |
| } |
| }; |
| |
| using FooFactory = std::function<Foo(int, float)>; |
| |
| fruit::Component<FooFactory> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<Foo(fruit::Assisted<int>, fruit::Assisted<float>)>( |
| [](int x, float y) { |
| return Foo(x, y); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<FooFactory> injector(getComponent); |
| FooFactory fooFactory(injector); |
| Foo foo = fooFactory(1, 2.3f); |
| (void)foo; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_2_assisted_params_returning_value(): |
| source = ''' |
| struct Foo { |
| Foo(int x, float y) { |
| (void)x; |
| (void)y; |
| } |
| }; |
| |
| using FooFactory = std::function<Foo(int, float)>; |
| |
| fruit::Component<FooFactory> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<Foo(fruit::Assisted<int>, fruit::Assisted<float>)>( |
| [](int x, float y) { |
| return Foo(x, y); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<FooFactory> injector(getComponent); |
| FooFactory fooFactory(injector); |
| Foo foo = fooFactory(1, 2.3f); |
| (void)foo; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_instances_bound_to_assisted_params(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| |
| struct Foo { |
| Foo(X x, Y y) { |
| (void)x; |
| (void)y; |
| } |
| }; |
| |
| using FooFactory = std::function<Foo()>; |
| |
| fruit::Component<FooFactory> getComponent() { |
| static X x = X(); |
| static Y y = Y(); |
| return fruit::createComponent() |
| .bindInstance(x) |
| .bindInstance(y) |
| .registerFactory<Foo(X, Y)>( |
| [](X x, Y y) { |
| return Foo(x, y); |
| }); |
| } |
| |
| |
| int main() { |
| fruit::Injector<FooFactory> injector(getComponent); |
| FooFactory fooFactory(injector); |
| Foo foo = fooFactory(); |
| (void)foo; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_2_assisted_params_plus_nonassisted_params(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| struct Z {}; |
| |
| struct Foo { |
| Foo(X, Y, int, float, Z) { |
| } |
| }; |
| |
| using FooPtrFactory = std::function<std::unique_ptr<Foo>(int, float)>; |
| |
| fruit::Component<FooPtrFactory> getComponent() { |
| static X x = X(); |
| static Y y = Y(); |
| static Z z = Z(); |
| return fruit::createComponent() |
| .bindInstance(x) |
| .bindInstance(y) |
| .bindInstance(z) |
| .registerFactory<std::unique_ptr<Foo>(X, Y, fruit::Assisted<int>, fruit::Assisted<float>, Z)>( |
| [](X x, Y y, int n, float a, Z z) { |
| return std::unique_ptr<Foo>(new Foo(x, y, n, a, z)); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<FooPtrFactory> injector(getComponent); |
| FooPtrFactory fooPtrFactory(injector); |
| std::unique_ptr<Foo> foo = fooPtrFactory(1, 3.4f); |
| (void)foo; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_2_assisted_params_plus_nonassisted_params_returning_value(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| struct Z {}; |
| |
| struct Foo { |
| Foo(X, Y, int, float, Z) { |
| } |
| }; |
| |
| using FooFactory = std::function<Foo(int, float)>; |
| |
| fruit::Component<FooFactory> getComponent() { |
| static X x = X(); |
| static Y y = Y(); |
| static Z z = Z(); |
| return fruit::createComponent() |
| .bindInstance(x) |
| .bindInstance(y) |
| .bindInstance(z) |
| .registerFactory<Foo(X, Y, fruit::Assisted<int>, fruit::Assisted<float>, Z)>( |
| [](X x, Y y, int n, float a, Z z) { |
| return Foo(x, y, n, a, z); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<FooFactory> injector(getComponent); |
| FooFactory fooFactory(injector); |
| Foo foo = fooFactory(1, 3.4f); |
| (void)foo; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_mixed_assisted_and_injected_params(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| |
| struct Foo { |
| Foo(int, float, X, Y, double) { |
| } |
| }; |
| |
| using FooFactory = std::function<Foo(int, float, double)>; |
| |
| fruit::Component<FooFactory> getComponent() { |
| static X x = X(); |
| static Y y = Y(); |
| return fruit::createComponent() |
| .bindInstance(x) |
| .bindInstance(y) |
| .registerFactory<Foo(fruit::Assisted<int>, fruit::Assisted<float>, X, Y, fruit::Assisted<double>)>( |
| [](int n, float a, X x, Y y, double d) { |
| return Foo(n, a, x, y, d); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<FooFactory> injector(getComponent); |
| FooFactory fooFactory(injector); |
| Foo foo = fooFactory(1, 3.4f, 3.456); |
| (void)foo; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_annotation_in_signature_return_type(): |
| source = ''' |
| struct X { |
| using Inject = fruit::Annotated<Annotation1, X>(); |
| }; |
| |
| fruit::Component<fruit::Annotated<Annotation1, std::function<std::unique_ptr<X>()>>> getComponent() { |
| return fruit::createComponent(); |
| } |
| ''' |
| expect_compile_error( |
| 'InjectTypedefWithAnnotationError<X>', |
| 'C::Inject is a signature that returns an annotated type', |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_annotation_in_signature_return_type_returning_value(): |
| source = ''' |
| struct X { |
| using Inject = fruit::Annotated<Annotation1, X>(); |
| }; |
| |
| fruit::Component<fruit::Annotated<Annotation1, std::function<X()>>> getComponent() { |
| return fruit::createComponent(); |
| } |
| ''' |
| expect_compile_error( |
| 'InjectTypedefWithAnnotationError<X>', |
| 'C::Inject is a signature that returns an annotated type', |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_from_provider_simple(): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor, X) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .registerProvider([](X x) { |
| return std::function<std::unique_ptr<ScalerImpl>(double)>([x](double n){ |
| return std::unique_ptr<ScalerImpl>(new ScalerImpl(n, x)); |
| }); |
| }) |
| .bind<Scaler, ScalerImpl>(); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerFactoryAnnot,MaybeConstScalerFactoryAnnot,ScalerImplAnnot,ScalerImplFactoryAnnot', [ |
| ('Scaler', |
| 'std::function<std::unique_ptr<Scaler>(double)>', |
| 'std::function<std::unique_ptr<Scaler>(double)>', |
| 'ScalerImpl', |
| 'std::function<std::unique_ptr<ScalerImpl>(double)>'), |
| ('Scaler', |
| 'std::function<std::unique_ptr<Scaler>(double)>', |
| 'const std::function<std::unique_ptr<Scaler>(double)>', |
| 'ScalerImpl', |
| 'std::function<std::unique_ptr<ScalerImpl>(double)>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation2, std::function<std::unique_ptr<ScalerImpl>(double)>>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation1, const std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation2, std::function<std::unique_ptr<ScalerImpl>(double)>>'), |
| ]) |
| def test_autoinject_from_provider(ScalerAnnot, ScalerFactoryAnnot, MaybeConstScalerFactoryAnnot, ScalerImplAnnot, ScalerImplFactoryAnnot): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor, X) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| using ScalerImplFactory = std::function<std::unique_ptr<ScalerImpl>(double)>; |
| |
| fruit::Component<MaybeConstScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .registerProvider<ScalerImplFactoryAnnot(X)>([](X x) { |
| return std::function<std::unique_ptr<ScalerImpl>(double)>([x](double n){ |
| return std::unique_ptr<ScalerImpl>(new ScalerImpl(n, x)); |
| }); |
| }) |
| .bind<ScalerAnnot, ScalerImplAnnot>(); |
| } |
| |
| int main() { |
| fruit::Injector<MaybeConstScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerFactoryAnnot', [ |
| 'ScalerFactory', |
| 'fruit::Annotated<Annotation1, ScalerFactory>', |
| ]) |
| def test_autoinject_from_provider_returning_value(ScalerFactoryAnnot): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| Scaler(double factor, X) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .registerProvider<ScalerFactoryAnnot(X)>([](X x) { |
| return std::function<Scaler(double)>([x](double n){ |
| return Scaler(n, x); |
| }); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('MaybeConst', [ |
| '', |
| 'const', |
| ]) |
| @pytest.mark.parametrize('X_ANNOT', [ |
| 'X', |
| 'ANNOTATED(Annotation1, X)', |
| ]) |
| def test_autoinject_with_binding(MaybeConst, X_ANNOT): |
| source = ''' |
| struct X { |
| using Inject = X(); |
| }; |
| |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| INJECT(ScalerImpl(ASSISTED(double) factor, X_ANNOT x)) |
| : factor(factor) { |
| (void)x; |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<MaybeConst ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImpl>(); |
| } |
| |
| int main() { |
| fruit::Injector<MaybeConst ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('MaybeConst', [ |
| '', |
| 'const', |
| ]) |
| @pytest.mark.parametrize('X_ANNOT', [ |
| 'X', |
| 'ANNOTATED(Annotation1, X)', |
| ]) |
| def test_autoinject_with_binding_returning_value(MaybeConst, X_ANNOT): |
| source = ''' |
| struct X { |
| using Inject = X(); |
| }; |
| |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| INJECT(Scaler(ASSISTED(double) factor, X_ANNOT x)) |
| : factor(factor) { |
| (void)x; |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<MaybeConst ScalerFactory> getScalerComponent() { |
| return fruit::createComponent(); |
| } |
| |
| int main() { |
| fruit::Injector<MaybeConst ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_autoinject_with_binding2(): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| INJECT(ScalerImpl(X, ASSISTED(double) factor)) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImpl>(); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_autoinject_with_binding2_returning_value(): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| INJECT(Scaler(X, ASSISTED(double) factor)) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent(); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerImplAnnot,ScalerFactoryAnnot', [ |
| ('Scaler', |
| 'ScalerImpl', |
| 'std::function<std::unique_ptr<Scaler>(double)>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>'), |
| ]) |
| def test_register_factory_success(ScalerAnnot, ScalerImplAnnot, ScalerFactoryAnnot): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot, ScalerImplAnnot>() |
| .registerFactory<ScalerImplAnnot(fruit::Assisted<double>)>([](double factor) { return ScalerImpl(factor); }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_with_annotation_returning_value(): |
| source = ''' |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| Scaler(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| using ScalerFactoryAnnot1 = fruit::Annotated<Annotation1, ScalerFactory>; |
| |
| fruit::Component<ScalerFactoryAnnot1> getScalerComponent() { |
| return fruit::createComponent() |
| .registerFactory<ScalerAnnot1(fruit::Assisted<double>)>( |
| [](double factor) { |
| return Scaler(factor); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot1> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot1>(); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_register_factory_with_different_annotation(): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| using ScalerFactoryAnnot1 = fruit::Annotated<Annotation1, ScalerFactory>; |
| |
| fruit::Component<ScalerFactoryAnnot1> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot1, ScalerImplAnnot2>() |
| .registerFactory<ScalerImplAnnot2(fruit::Assisted<double>)>( |
| [](double factor) { |
| return ScalerImpl(factor); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot1> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot1>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerImplAnnot,ScalerFactoryAnnot', [ |
| ('Scaler', |
| 'ScalerImpl', |
| 'std::function<std::unique_ptr<Scaler>(double, double)>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double, double)>>'), |
| ]) |
| def test_register_factory_2arg_success(ScalerAnnot, ScalerImplAnnot, ScalerFactoryAnnot): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double, double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot, ScalerImplAnnot>() |
| .registerFactory<ScalerImplAnnot(fruit::Assisted<double>, fruit::Assisted<double>)>( |
| [](double factor, double) { |
| return ScalerImpl(factor); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1, 34.2); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_with_different_annotation_error(): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| using ScalerFactoryAnnot1 = fruit::Annotated<Annotation1, ScalerFactory>; |
| |
| fruit::Component<ScalerFactoryAnnot1> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot1, ScalerImplAnnot1>() |
| .registerFactory<ScalerImplAnnot2(fruit::Assisted<double>)>([](double factor) { return ScalerImpl(factor); }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot1> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot1>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_compile_error( |
| 'NoBindingFoundError<fruit::Annotated<Annotation1,std::function<std::unique_ptr<ScalerImpl(,std::default_delete<ScalerImpl>)?>\(double\)>>>', |
| '', |
| COMMON_DEFINITIONS, |
| source) |
| |
| |
| def test_register_factory_dep_on_provider(): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImpl>() |
| .registerProvider([](){return 23;}) |
| .registerFactory<ScalerImpl(fruit::Assisted<double>, fruit::Provider<int>)>( |
| [](double factor, fruit::Provider<int> provider) { |
| return ScalerImpl(factor * provider.get<int>()); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_register_factory_dep_on_provider_returning_value(): |
| source = ''' |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| Scaler(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .registerProvider([](){return 23;}) |
| .registerFactory<Scaler(fruit::Assisted<double>, fruit::Provider<int>)>( |
| [](double factor, fruit::Provider<int> provider) { |
| return Scaler(factor * provider.get<int>()); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_register_factory_error_abstract_class(): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| // Note: here we "forgot" to implement scale() (on purpose, for this test) so ScalerImpl is an abstract class. |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImpl>() |
| .registerFactory<fruit::Annotated<Annotation1, ScalerImpl>(fruit::Assisted<double>)>([](double) { return (ScalerImpl*)nullptr; }); |
| } |
| ''' |
| expect_compile_error( |
| 'CannotConstructAbstractClassError<ScalerImpl>', |
| 'The specified class can.t be constructed because it.s an abstract class.', |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_register_factory_error_not_function(): |
| source = ''' |
| struct X { |
| X(int) {} |
| }; |
| |
| fruit::Component<std::function<X()>> getComponent() { |
| int n = 3; |
| return fruit::createComponent() |
| .registerFactory<X()>([=]{return X(n);}); |
| } |
| ''' |
| expect_compile_error( |
| 'LambdaWithCapturesError<.*>', |
| 'Only lambdas with no captures are supported', |
| COMMON_DEFINITIONS, |
| source) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerImplAnnot,ScalerImplPtrAnnot,ScalerFactoryAnnot,ScalerImplFactorySignatureAnnotRegex', [ |
| ('Scaler', |
| 'ScalerImpl', |
| 'ScalerImpl*', |
| 'std::function<std::unique_ptr<Scaler>(double)>', |
| 'ScalerImpl\*\(fruit::Assisted<double>\)'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation2, ScalerImpl*>', |
| 'fruit::Annotated<Annotation2, std::function<std::unique_ptr<Scaler>(double)>>', |
| 'fruit::Annotated<Annotation2,ScalerImpl\*>\(fruit::Assisted<double>\)') |
| ]) |
| def test_register_factory_for_pointer(ScalerAnnot, ScalerImplAnnot, ScalerImplPtrAnnot, ScalerFactoryAnnot, ScalerImplFactorySignatureAnnotRegex): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot, ScalerImplAnnot>() |
| .registerFactory<ScalerImplPtrAnnot(fruit::Assisted<double>)>([](double factor) { return new ScalerImpl(factor); }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_compile_error( |
| 'FactoryReturningPointerError<ScalerImplFactorySignatureAnnotRegex>', |
| 'The specified factory returns a pointer. This is not supported', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerPtrAnnot,ScalerFactoryAnnot,ScalerFactorySignatureAnnotRegex', [ |
| ('Scaler*', |
| 'std::function<Scaler(double)>', |
| 'Scaler\*\(fruit::Assisted<double>\)'), |
| ('fruit::Annotated<Annotation1, Scaler*>', |
| 'fruit::Annotated<Annotation1, std::function<Scaler(double)>>', |
| 'fruit::Annotated<Annotation1,Scaler\*>\(fruit::Assisted<double>\)'), |
| ]) |
| def test_register_factory_for_pointer_returning_value(ScalerPtrAnnot, ScalerFactoryAnnot, ScalerFactorySignatureAnnotRegex): |
| source = ''' |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| Scaler(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .registerFactory<ScalerPtrAnnot(fruit::Assisted<double>)>([](double factor) { return new Scaler(factor); }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_compile_error( |
| 'FactoryReturningPointerError<ScalerFactorySignatureAnnotRegex>', |
| 'The specified factory returns a pointer. This is not supported', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerImplAnnot,ScalerImplPtrAnnot,ScalerFactoryAnnot', [ |
| ('Scaler', |
| 'ScalerImpl', |
| 'std::unique_ptr<ScalerImpl>', |
| 'std::function<std::unique_ptr<Scaler>(double)>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation2, std::unique_ptr<ScalerImpl>>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>'), |
| ]) |
| def test_register_factory_for_unique_pointer(ScalerAnnot, ScalerImplAnnot, ScalerImplPtrAnnot, ScalerFactoryAnnot): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot, ScalerImplAnnot>() |
| .registerFactory<ScalerImplPtrAnnot(fruit::Assisted<double>)>( |
| [](double factor) { |
| return std::unique_ptr<ScalerImpl>(new ScalerImpl(factor)); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerImplAnnot,ScalerImplPtrAnnot,ScalerFactoryAnnot', [ |
| ('Scaler', |
| 'ScalerImpl', |
| 'std::unique_ptr<ScalerImpl>', |
| 'std::function<std::unique_ptr<Scaler>(double)>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation2, ScalerImpl>', |
| 'fruit::Annotated<Annotation2, std::unique_ptr<ScalerImpl>>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<Scaler>(double)>>'), |
| ]) |
| def test_register_factory_for_unique_pointer_returning_invalid_unique_ptr_ok(ScalerAnnot, ScalerImplAnnot, ScalerImplPtrAnnot, ScalerFactoryAnnot): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| virtual ~Scaler() = default; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<ScalerAnnot, ScalerImplAnnot>() |
| .registerFactory<ScalerImplPtrAnnot(fruit::Assisted<double>)>( |
| [](double) { |
| return std::unique_ptr<ScalerImpl>(nullptr); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| Assert(scaler.get() == nullptr); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerAnnot,ScalerFactoryAnnot', [ |
| ('Scaler', |
| 'std::function<Scaler(double)>'), |
| ('fruit::Annotated<Annotation1, Scaler>', |
| 'fruit::Annotated<Annotation1, std::function<Scaler(double)>>'), |
| ]) |
| def test_register_factory_for_unique_pointer_returning_value(ScalerAnnot, ScalerFactoryAnnot): |
| source = ''' |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| Scaler(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<ScalerFactoryAnnot> getScalerComponent() { |
| return fruit::createComponent() |
| .registerFactory<ScalerAnnot(fruit::Assisted<double>)>( |
| [](double factor) { |
| return Scaler(factor); |
| }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactoryAnnot> injector(getScalerComponent); |
| ScalerFactory scalerFactory = injector.get<ScalerFactoryAnnot>(); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ScalerImplAnnot', [ |
| 'ScalerImpl', |
| 'fruit::Annotated<Annotation1, ScalerImpl>', |
| ]) |
| def test_register_factory_inconsistent_signature(ScalerImplAnnot): |
| source = ''' |
| struct Scaler { |
| virtual double scale(double x) = 0; |
| }; |
| |
| struct ScalerImpl : public Scaler { |
| private: |
| double factor; |
| |
| public: |
| ScalerImpl(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) override { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<std::unique_ptr<Scaler>(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .bind<Scaler, ScalerImplAnnot>() |
| .registerFactory<ScalerImplAnnot(fruit::Assisted<double>)>([](float factor) { return ScalerImpl(factor); }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| std::unique_ptr<Scaler> scaler = scalerFactory(12.1); |
| std::cout << scaler->scale(3) << std::endl; |
| } |
| ''' |
| expect_compile_error( |
| 'FunctorSignatureDoesNotMatchError<ScalerImpl\(double\),ScalerImpl\(float\)>', |
| 'Unexpected functor signature', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_inconsistent_signature_returning_value(): |
| source = ''' |
| struct Scaler { |
| private: |
| double factor; |
| |
| public: |
| Scaler(double factor) |
| : factor(factor) { |
| } |
| |
| double scale(double x) { |
| return x * factor; |
| } |
| }; |
| |
| using ScalerFactory = std::function<Scaler(double)>; |
| |
| fruit::Component<ScalerFactory> getScalerComponent() { |
| return fruit::createComponent() |
| .registerFactory<Scaler(fruit::Assisted<double>)>([](float factor) { return Scaler(factor); }); |
| } |
| |
| int main() { |
| fruit::Injector<ScalerFactory> injector(getScalerComponent); |
| ScalerFactory scalerFactory(injector); |
| Scaler scaler = scalerFactory(12.1); |
| std::cout << scaler.scale(3) << std::endl; |
| } |
| ''' |
| expect_compile_error( |
| 'FunctorSignatureDoesNotMatchError<Scaler\(double\),Scaler\(float\)>', |
| 'Unexpected functor signature', |
| COMMON_DEFINITIONS, |
| source) |
| |
| def test_register_factory_nonmovable_ok(): |
| source = ''' |
| struct C { |
| INJECT(C()) = default; |
| |
| C(const C&) = delete; |
| C(C&&) = delete; |
| C& operator=(const C&) = delete; |
| C& operator=(C&&) = delete; |
| }; |
| |
| using CFactory = std::function<std::unique_ptr<C>()>; |
| |
| fruit::Component<CFactory> getCFactory() { |
| return fruit::createComponent(); |
| } |
| |
| int main() { |
| fruit::Injector<CFactory> injector(getCFactory); |
| CFactory cFactory(injector); |
| std::unique_ptr<C> c = cFactory(); |
| (void)c; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source) |
| |
| # TODO: this might not be the best error message, maybe we should ignore the constructor entirely in the message, |
| # or mention that there are other ways to satisfy that dependency. |
| @pytest.mark.parametrize('XAnnot,XFactoryAnnot', [ |
| ('X', |
| 'std::function<X(int)>'), |
| ('fruit::Annotated<Annotation1, X>', |
| 'fruit::Annotated<Annotation1, std::function<X(int)>>'), |
| ]) |
| def test_register_factory_not_existing_constructor1(XAnnot, XFactoryAnnot): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| fruit::Component<XFactoryAnnot> getComponent() { |
| return fruit::createComponent(); |
| } |
| ''' |
| expect_compile_error( |
| 'FunctorSignatureDoesNotMatchError<XAnnot\(int\),XAnnot\((void)?\)>', |
| 'Unexpected functor signature', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| # TODO: this might not be the best error message, maybe we should ignore the constructor entirely in the message, |
| # or mention that there are other ways to satisfy that dependency. |
| @pytest.mark.parametrize('XIntFactoryAnnot,XIntFactoryAnnotRegex,XVoidFactoryAnnotRegex', [ |
| ('std::function<std::unique_ptr<X>(int)>', |
| 'std::unique_ptr<X(,std::default_delete<X>)?>\(int\)', |
| 'std::unique_ptr<X(,std::default_delete<X>)?>\((void)?\)'), |
| ('fruit::Annotated<Annotation1, std::function<std::unique_ptr<X>(int)>>', |
| 'fruit::Annotated<Annotation1,std::unique_ptr<X(,std::default_delete<X>)?>>\(int\)', |
| 'fruit::Annotated<Annotation1,std::unique_ptr<X(,std::default_delete<X>)?>>\((void)?\)') |
| ]) |
| def test_register_factory_not_existing_constructor2(XIntFactoryAnnot, XIntFactoryAnnotRegex, XVoidFactoryAnnotRegex): |
| source = ''' |
| struct X { |
| using Inject = X(); |
| }; |
| |
| fruit::Component<XIntFactoryAnnot> getComponent() { |
| return fruit::createComponent(); |
| } |
| ''' |
| expect_compile_error( |
| 'FunctorSignatureDoesNotMatchError<XIntFactoryAnnotRegex,XVoidFactoryAnnotRegex>', |
| 'Unexpected functor signature', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| # TODO: this might not be the best error message, maybe we should ignore the constructor entirely in the message, |
| # or mention that there are other ways to satisfy that dependency. |
| @pytest.mark.parametrize('XAnnot,XFactoryAnnot', [ |
| ('X', |
| 'std::function<X(int)>'), |
| ('fruit::Annotated<Annotation1, X>', |
| 'fruit::Annotated<Annotation1, std::function<X(int)>>'), |
| ]) |
| def test_register_factory_not_existing_constructor2_returning_value(XAnnot, XFactoryAnnot): |
| source = ''' |
| struct X { |
| using Inject = X(); |
| }; |
| |
| fruit::Component<XFactoryAnnot> getComponent() { |
| return fruit::createComponent(); |
| } |
| ''' |
| expect_compile_error( |
| 'FunctorSignatureDoesNotMatchError<XAnnot\(int\), XAnnot\((void)?\)>', |
| 'Unexpected functor signature', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| |
| @pytest.mark.parametrize('XFactoryAnnot', [ |
| 'std::function<X()>', |
| 'fruit::Annotated<Annotation1, std::function<X()>>', |
| ]) |
| def test_register_factory_success_factory_movable_only_implicit(XFactoryAnnot): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| X(X&&) = default; |
| X(const X&) = delete; |
| }; |
| |
| fruit::Component<XFactoryAnnot> getComponent() { |
| return fruit::createComponent(); |
| } |
| |
| int main() { |
| fruit::Injector<XFactoryAnnot> injector(getComponent); |
| injector.get<XFactoryAnnot>()(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('XPtrAnnot,ConstructX,XPtrFactoryAnnot', [ |
| ('X', 'X()', 'std::function<X()>'), |
| ('fruit::Annotated<Annotation1, X>', 'X()', 'fruit::Annotated<Annotation1, std::function<X()>>'), |
| ('std::unique_ptr<X>', 'std::unique_ptr<X>(new X())', 'std::function<std::unique_ptr<X>()>'), |
| ('fruit::Annotated<Annotation1, std::unique_ptr<X>>', 'std::unique_ptr<X>(new X())', 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<X>()>>'), |
| ]) |
| def test_register_factory_success_factory_movable_only_explicit(XPtrAnnot, ConstructX, XPtrFactoryAnnot): |
| source = ''' |
| struct X { |
| X() = default; |
| X(X&&) = default; |
| X(const X&) = delete; |
| }; |
| |
| fruit::Component<XPtrFactoryAnnot> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<XPtrAnnot()>([](){return ConstructX;}); |
| } |
| |
| int main() { |
| fruit::Injector<XPtrFactoryAnnot> injector(getComponent); |
| injector.get<XPtrFactoryAnnot>()(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('XPtrFactoryAnnot', [ |
| 'std::function<std::unique_ptr<X>()>', |
| 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<X>()>>', |
| ]) |
| def test_register_factory_success_factory_not_movable_implicit(XPtrFactoryAnnot): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| X(X&&) = delete; |
| X(const X&) = delete; |
| }; |
| |
| fruit::Component<XPtrFactoryAnnot> getComponent() { |
| return fruit::createComponent(); |
| } |
| |
| int main() { |
| fruit::Injector<XPtrFactoryAnnot> injector(getComponent); |
| injector.get<XPtrFactoryAnnot>()(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('XPtrAnnot,XPtrFactoryAnnot', [ |
| ('std::unique_ptr<X>', 'std::function<std::unique_ptr<X>()>'), |
| ('fruit::Annotated<Annotation1, std::unique_ptr<X>>', 'fruit::Annotated<Annotation1, std::function<std::unique_ptr<X>()>>'), |
| ]) |
| def test_register_factory_success_factory_not_movable_explicit_returning_pointer(XPtrAnnot, XPtrFactoryAnnot): |
| source = ''' |
| struct X { |
| X() = default; |
| X(X&&) = delete; |
| X(const X&) = delete; |
| }; |
| |
| fruit::Component<XPtrFactoryAnnot> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<XPtrAnnot()>([](){return std::unique_ptr<X>(new X());}); |
| } |
| |
| int main() { |
| fruit::Injector<XPtrFactoryAnnot> injector(getComponent); |
| injector.get<XPtrFactoryAnnot>()(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ConstructX,XPtr', [ |
| ('X()', 'X'), |
| ('std::unique_ptr<X>(new X())', 'std::unique_ptr<X>'), |
| ]) |
| @pytest.mark.parametrize('WithAnnot', [ |
| 'WithNoAnnotation', |
| 'WithAnnotation1', |
| ]) |
| @pytest.mark.parametrize('YVariant', [ |
| 'Y', |
| 'Y*', |
| 'const Y*', |
| 'Y&', |
| 'const Y&', |
| 'std::shared_ptr<Y>', |
| 'fruit::Provider<Y>', |
| 'fruit::Provider<const Y>', |
| ]) |
| def test_register_factory_with_param_success(ConstructX, XPtr, WithAnnot, YVariant): |
| source = ''' |
| struct Y {}; |
| struct X {}; |
| |
| fruit::Component<WithAnnot<Y>> getYComponent() { |
| return fruit::createComponent() |
| .registerConstructor<WithAnnot<Y>()>(); |
| } |
| |
| fruit::Component<std::function<XPtr()>> getComponent() { |
| return fruit::createComponent() |
| .install(getYComponent) |
| .registerFactory<XPtr(WithAnnot<YVariant>)>([](YVariant){ return ConstructX; }); |
| } |
| |
| int main() { |
| fruit::Injector<std::function<XPtr()>> injector(getComponent); |
| XPtr x = injector.get<std::function<XPtr()>>()(); |
| (void) x; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ConstructX,XPtr', [ |
| ('X()', 'X'), |
| ('std::unique_ptr<X>(new X())', 'std::unique_ptr<X>'), |
| ]) |
| @pytest.mark.parametrize('WithAnnot', [ |
| 'WithNoAnnotation', |
| 'WithAnnotation1', |
| ]) |
| @pytest.mark.parametrize('YVariant', [ |
| 'Y', |
| 'const Y*', |
| 'const Y&', |
| 'fruit::Provider<const Y>', |
| ]) |
| def test_register_factory_with_param_const_binding_success(ConstructX, XPtr, WithAnnot, YVariant): |
| source = ''' |
| struct Y {}; |
| struct X {}; |
| |
| const Y y{}; |
| |
| fruit::Component<WithAnnot<const Y>> getYComponent() { |
| return fruit::createComponent() |
| .bindInstance<WithAnnot<Y>, Y>(y); |
| } |
| |
| fruit::Component<std::function<XPtr()>> getComponent() { |
| return fruit::createComponent() |
| .install(getYComponent) |
| .registerFactory<XPtr(WithAnnot<YVariant>)>([](YVariant){ return ConstructX; }); |
| } |
| |
| int main() { |
| fruit::Injector<std::function<XPtr()>> injector(getComponent); |
| XPtr x = injector.get<std::function<XPtr()>>()(); |
| (void) x; |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ConstructX,XPtr', [ |
| ('X()', 'X'), |
| ('std::unique_ptr<X>(new X())', 'std::unique_ptr<X>'), |
| ]) |
| @pytest.mark.parametrize('WithAnnot,YAnnotRegex', [ |
| ('WithNoAnnotation', 'Y'), |
| ('WithAnnotation1', 'fruit::Annotated<Annotation1, Y>'), |
| ]) |
| @pytest.mark.parametrize('XFactoryResult', [ |
| 'X', |
| 'std::unique_ptr<X>', |
| ]) |
| @pytest.mark.parametrize('YVariant', [ |
| 'Y*', |
| 'Y&', |
| 'std::shared_ptr<Y>', |
| 'fruit::Provider<Y>', |
| ]) |
| def test_register_factory_with_param_error_nonconst_param_required(ConstructX, XPtr, WithAnnot, YAnnotRegex, XFactoryResult, YVariant): |
| source = ''' |
| struct Y {}; |
| struct X {}; |
| |
| fruit::Component<WithAnnot<const Y>> getYComponent(); |
| |
| fruit::Component<std::function<XFactoryResult()>> getComponent() { |
| return fruit::createComponent() |
| .install(getYComponent) |
| .registerFactory<XPtr(WithAnnot<YVariant>)>([](YVariant){ return ConstructX; }); |
| } |
| ''' |
| expect_compile_error( |
| 'NonConstBindingRequiredButConstBindingProvidedError<YAnnotRegex>', |
| 'The type T was provided as constant, however one of the constructors/providers/factories in this component', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('ConstructX,XPtr', [ |
| ('X()', 'X'), |
| ('std::unique_ptr<X>(new X())', 'std::unique_ptr<X>'), |
| ]) |
| @pytest.mark.parametrize('XFactoryResult', [ |
| 'X', |
| 'std::unique_ptr<X>', |
| ]) |
| @pytest.mark.parametrize('WithAnnot,YAnnotRegex', [ |
| ('WithNoAnnotation', 'Y'), |
| ('WithAnnotation1', 'fruit::Annotated<Annotation1, Y>'), |
| ]) |
| @pytest.mark.parametrize('YVariant', [ |
| 'Y*', |
| 'Y&', |
| 'std::shared_ptr<Y>', |
| 'fruit::Provider<Y>', |
| ]) |
| def test_register_factory_with_param_error_nonconst_param_required_install_after(ConstructX, XPtr, XFactoryResult, WithAnnot, YAnnotRegex, YVariant): |
| source = ''' |
| struct Y {}; |
| struct X {}; |
| |
| fruit::Component<WithAnnot<const Y>> getYComponent(); |
| |
| fruit::Component<std::function<XFactoryResult()>> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<XPtr(WithAnnot<YVariant>)>([](YVariant){ return ConstructX; }) |
| .install(getYComponent); |
| } |
| ''' |
| expect_compile_error( |
| 'NonConstBindingRequiredButConstBindingProvidedError<YAnnotRegex>', |
| 'The type T was provided as constant, however one of the constructors/providers/factories in this component', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_requiring_nonconst_then_requiring_const_ok(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| struct Z {}; |
| |
| fruit::Component<std::function<Y()>, std::function<Z()>> getRootComponent() { |
| return fruit::createComponent() |
| .registerFactory<Y(X&)>([](X&) { return Y();}) |
| .registerFactory<Z(const X&)>([](const X&) { return Z();}) |
| .registerConstructor<X()>(); |
| } |
| |
| int main() { |
| fruit::Injector<std::function<Y()>, std::function<Z()>> injector(getRootComponent); |
| std::function<Y()> yFactory = injector.get<std::function<Y()>>(); |
| yFactory(); |
| std::function<Z()> zFactory = injector.get<std::function<Z()>>(); |
| zFactory(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_requiring_nonconst_then_requiring_const_declaring_const_requirement_error(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| struct Z {}; |
| |
| fruit::Component<fruit::Required<const X>, std::function<Y()>, std::function<Z()>> getRootComponent() { |
| return fruit::createComponent() |
| .registerFactory<Y(X&)>([](X&) { return Y();}) |
| .registerFactory<Z(const X&)>([](const X&) { return Z();}); |
| } |
| ''' |
| expect_compile_error( |
| 'ConstBindingDeclaredAsRequiredButNonConstBindingRequiredError<X>', |
| 'The type T was declared as a const Required type in the returned Component, however', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_requiring_const_then_requiring_nonconst_ok(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| struct Z {}; |
| |
| fruit::Component<std::function<Y()>, std::function<Z()>> getRootComponent() { |
| return fruit::createComponent() |
| .registerFactory<Y(const X&)>([](const X&) { return Y();}) |
| .registerFactory<Z(X&)>([](X&) { return Z();}) |
| .registerConstructor<X()>(); |
| } |
| |
| int main() { |
| fruit::Injector<std::function<Y()>, std::function<Z()>> injector(getRootComponent); |
| std::function<Y()> yFactory = injector.get<std::function<Y()>>(); |
| yFactory(); |
| std::function<Z()> zFactory = injector.get<std::function<Z()>>(); |
| zFactory(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_requiring_const_then_requiring_nonconst_declaring_const_requirement_error(): |
| source = ''' |
| struct X {}; |
| struct Y {}; |
| struct Z {}; |
| |
| fruit::Component<fruit::Required<const X>, std::function<Y()>, std::function<Z()>> getRootComponent() { |
| return fruit::createComponent() |
| .registerFactory<Y(const X&)>([](const X&) { return Y();}) |
| .registerFactory<Z(X&)>([](X&) { return Z();}); |
| } |
| ''' |
| expect_compile_error( |
| 'ConstBindingDeclaredAsRequiredButNonConstBindingRequiredError<X>', |
| 'The type T was declared as a const Required type in the returned Component, however', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_provider_get_error_type_unique_pointer_pointer_not_provided(): |
| source = ''' |
| struct X {}; |
| |
| void f(fruit::Provider<X> provider) { |
| provider.get<std::unique_ptr<X>*>(); |
| } |
| ''' |
| expect_compile_error( |
| 'TypeNotProvidedError<std::unique_ptr<X(,std::default_delete<X>)?>\*>', |
| 'Trying to get an instance of T, but it is not provided by this Provider/Injector.', |
| COMMON_DEFINITIONS, |
| source) |
| |
| @pytest.mark.parametrize('ConstructX,XPtr', [ |
| ('X()', 'X'), |
| ('std::unique_ptr<X>(new X())', 'std::unique_ptr<X>'), |
| ]) |
| @pytest.mark.parametrize('XFactoryResult', [ |
| 'X', |
| 'std::unique_ptr<X>', |
| ]) |
| @pytest.mark.parametrize('YVariant,YVariantRegex', [ |
| ('Y**', r'Y\*\*'), |
| ('std::shared_ptr<Y>*', r'std::shared_ptr<Y>\*'), |
| ('std::nullptr_t', r'(std::)?nullptr(_t)?'), |
| ('Y*&', r'Y\*&'), |
| ('Y(*)()', r'Y(\((__cdecl)?\*\))?\((void)?\)'), |
| ('fruit::Annotated<Annotation1, Y**>', r'Y\*\*'), |
| ]) |
| def test_register_factory_with_param_error_type_not_injectable( |
| ConstructX, XPtr, XFactoryResult, YVariant, YVariantRegex): |
| source = ''' |
| struct Y {}; |
| struct X {}; |
| |
| fruit::Component<> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<XPtr(YVariant)>([](YVariant){ return ConstructX; }); |
| } |
| ''' |
| expect_compile_error( |
| 'NonInjectableTypeError<YVariantRegex>', |
| 'The type T is not injectable.', |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_bind_nonconst_unique_ptr_factory_to_const_value_factory(): |
| source = ''' |
| struct X { |
| INJECT(X()) = default; |
| }; |
| |
| fruit::Component<const std::function<X()>> getChildComponent() { |
| return fruit::createComponent(); |
| } |
| |
| fruit::Component<std::function<std::unique_ptr<X>()>> getRootComponent() { |
| return fruit::createComponent() |
| .install(getChildComponent); |
| } |
| |
| int main() { |
| fruit::Injector<std::function<std::unique_ptr<X>()>> injector(getRootComponent); |
| std::function<std::unique_ptr<X>()> xFactory(injector); |
| xFactory(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_bind_const_interface_factory_to_nonconst_implementation_factory(): |
| source = ''' |
| struct X { |
| virtual void foo() = 0; |
| virtual ~X() = default; |
| }; |
| |
| struct Y : public X { |
| INJECT(Y()) = default; |
| |
| void foo() override { |
| } |
| }; |
| |
| fruit::Component<std::function<std::unique_ptr<Y>()>> getChildComponent() { |
| return fruit::createComponent(); |
| } |
| |
| fruit::Component<const std::function<std::unique_ptr<X>()>> getRootComponent() { |
| return fruit::createComponent() |
| .install(getChildComponent) |
| .bind<X, Y>(); |
| } |
| |
| int main() { |
| fruit::Injector<const std::function<std::unique_ptr<X>()>> injector(getRootComponent); |
| std::function<std::unique_ptr<X>()> xFactory(injector); |
| xFactory(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| def test_register_factory_bind_nonconst_interface_factory_to_const_implementation_factory(): |
| source = ''' |
| struct X { |
| virtual void foo() = 0; |
| virtual ~X() = default; |
| }; |
| |
| struct Y : public X { |
| INJECT(Y()) = default; |
| |
| void foo() override { |
| } |
| }; |
| |
| fruit::Component<const std::function<std::unique_ptr<Y>()>> getChildComponent() { |
| return fruit::createComponent(); |
| } |
| |
| fruit::Component<std::function<std::unique_ptr<X>()>> getRootComponent() { |
| return fruit::createComponent() |
| .install(getChildComponent) |
| .bind<X, Y>(); |
| } |
| |
| int main() { |
| fruit::Injector<std::function<std::unique_ptr<X>()>> injector(getRootComponent); |
| std::function<std::unique_ptr<X>()> xFactory(injector); |
| xFactory(); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| @pytest.mark.parametrize('WithAnnot', [ |
| 'WithNoAnnotation', |
| 'WithAnnotation1', |
| ]) |
| def test_register_factory_abstract_class_ok(WithAnnot): |
| source = ''' |
| struct I { |
| virtual int foo() = 0; |
| virtual ~I() = default; |
| }; |
| |
| struct X : public I { |
| int foo() override { |
| return 5; |
| } |
| }; |
| |
| fruit::Component<WithAnnot<std::function<std::unique_ptr<I>()>>> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<WithAnnot<std::unique_ptr<I>>()>([](){return std::unique_ptr<I>(static_cast<I*>(new X()));}); |
| } |
| |
| int main() { |
| fruit::Injector<WithAnnot<std::function<std::unique_ptr<I>()>>> injector(getComponent); |
| |
| Assert(injector.get<WithAnnot<std::function<std::unique_ptr<I>()>>>()()->foo() == 5); |
| } |
| ''' |
| expect_success( |
| COMMON_DEFINITIONS, |
| source, |
| locals()) |
| |
| # TODO: investigate why this doesn't fail to compile with MSVC and then re-enable it for MSVC too. |
| @pytest.mark.skipif( |
| re.search('MSVC', CXX_COMPILER_NAME), |
| reason = 'This is disabled in MSVC because it compiles cleanly with the latest MSVC.') |
| @pytest.mark.parametrize('WithAnnot', [ |
| 'WithNoAnnotation', |
| 'WithAnnotation1', |
| ]) |
| def test_register_factory_abstract_class_with_no_virtual_destructor_error(WithAnnot): |
| source = ''' |
| struct I { |
| virtual int foo() = 0; |
| }; |
| |
| struct X : public I { |
| int foo() override { |
| return 5; |
| } |
| }; |
| |
| fruit::Component<WithAnnot<std::function<std::unique_ptr<I>()>>> getComponent() { |
| return fruit::createComponent() |
| .registerFactory<WithAnnot<std::unique_ptr<I>>()>([](){return std::unique_ptr<I>(static_cast<I*>(new X()));}); |
| } |
| ''' |
| expect_compile_error( |
| 'RegisterFactoryForUniquePtrOfAbstractClassWithNoVirtualDestructorError<I>', |
| 'registerFactory\(\) was called with a lambda that returns a std::unique_ptr<T>, but T is an abstract class', |
| COMMON_DEFINITIONS, |
| source, |
| locals(), |
| ignore_warnings=True, |
| disable_error_line_number_check=True) |
| |
| if __name__== '__main__': |
| main(__file__) |
