#!/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.

from fruit_test_common import *

COMMON_DEFINITIONS = '''
    #include "test_common.h"

    struct X;

    struct Annotation1 {};
    using XAnnot1 = fruit::Annotated<Annotation1, X>;
    '''

def test_required_success():
    source = '''
        struct X {
            virtual void foo() = 0;
            virtual ~X() = default;
        };
        using XFactory = std::function<std::unique_ptr<X>()>;
        struct Y {
            XFactory xFactory;

            INJECT(Y(XFactory xFactory))
                : xFactory(xFactory) {
            }

            void doStuff() {
                xFactory()->foo();
            }
        };
        fruit::Component<fruit::Required<XFactory>, Y> getYComponent() {
            return fruit::createComponent();
        }
        struct XImpl : public X {
            INJECT(XImpl()) = default;
            void foo() override {}
        };
        fruit::Component<XFactory> getXFactoryComponent() {
            return fruit::createComponent()
                .bind<X, XImpl>();
        }
        fruit::Component<Y> getComponent() {
            return fruit::createComponent()
                .install(getYComponent)
                .install(getXFactoryComponent);
        }
        int main() {
            fruit::Injector<Y> injector(getComponent);
            Y* y(injector);
            y->doStuff();
        }
        '''
    expect_success(COMMON_DEFINITIONS, source)

def test_required_annotated_success():
    source = '''
        struct X {
            virtual void foo() = 0;
            virtual ~X() = default;
        };
        using XFactory = std::function<std::unique_ptr<X>()>;
        using XFactoryAnnot = fruit::Annotated<Annotation1, XFactory>;
        struct Y {
            XFactory xFactory;

            INJECT(Y(ANNOTATED(Annotation1, XFactory) xFactory))
                : xFactory(xFactory) {
            }

            void doStuff() {
                xFactory()->foo();
            }
        };
        fruit::Component<fruit::Required<XFactoryAnnot>, Y> getYComponent() {
            return fruit::createComponent();
        }
        struct XImpl : public X {
            INJECT(XImpl()) = default;
            void foo() override {}
        };
        fruit::Component<XFactoryAnnot> getXFactoryComponent() {
            return fruit::createComponent()
                .bind<fruit::Annotated<Annotation1, X>, fruit::Annotated<Annotation1, XImpl>>();
        }
        fruit::Component<Y> getComponent() {
            return fruit::createComponent()
                .install(getYComponent)
                .install(getXFactoryComponent);
        }
        int main() {
            fruit::Injector<Y> injector(getComponent);
            Y* y(injector);
            y->doStuff();
        }
        '''
    expect_success(COMMON_DEFINITIONS, source)

def test_required_forward_declared_success():
    source = '''
        struct X;
        using XFactory = std::function<std::unique_ptr<X>()>;
        struct Y {
            XFactory xFactory;

            INJECT(Y(XFactory xFactory))
                : xFactory(xFactory) {
            }

            void doStuff();
        };
        fruit::Component<fruit::Required<XFactory>, Y> getYComponent() {
            return fruit::createComponent();
        }
        fruit::Component<XFactory> getXFactoryComponent();
        fruit::Component<Y> getComponent() {
            return fruit::createComponent()
                .install(getYComponent)
                .install(getXFactoryComponent);
        }
        int main() {
            fruit::Injector<Y> injector(getComponent);
            Y* y(injector);
            y->doStuff();
        }

        // We define X as late as possible, to make sure that all the above compiles even if X is only forward-declared.
        struct X {
            virtual void foo() = 0;
            virtual ~X() = default;
        };
        void Y::doStuff() {
            xFactory()->foo();
        }
        struct XImpl : public X {
            INJECT(XImpl()) = default;
            void foo() override {}
        };
        fruit::Component<XFactory> getXFactoryComponent() {
            return fruit::createComponent()
                .bind<X, XImpl>();
        }
        '''
    expect_success(COMMON_DEFINITIONS, source)

def test_required_annotated_forward_declared_success():
    source = '''
        struct X;
        using XFactory = std::function<std::unique_ptr<X>()>;
        using XFactoryAnnot = fruit::Annotated<Annotation1, XFactory>;
        struct Y {
            XFactory xFactory;

            INJECT(Y(ANNOTATED(Annotation1, XFactory) xFactory))
                : xFactory(xFactory) {
            }

            void doStuff();
        };
        fruit::Component<fruit::Required<XFactoryAnnot>, Y> getYComponent() {
            return fruit::createComponent();
        }
        fruit::Component<XFactoryAnnot> getXFactoryComponent();
        fruit::Component<Y> getComponent() {
            return fruit::createComponent()
                .install(getYComponent)
                .install(getXFactoryComponent);
        }
        int main() {
            fruit::Injector<Y> injector(getComponent);
            Y* y(injector);
            y->doStuff();
        }

        // We define X as late as possible, to make sure that all the above compiles even if X is only forward-declared.
        struct X {
            virtual void foo() = 0;
            virtual ~X() = default;
        };
        void Y::doStuff() {
            xFactory()->foo();
        }
        struct XImpl : public X {
            INJECT(XImpl()) = default;
            void foo() override {}
        };
        fruit::Component<XFactoryAnnot> getXFactoryComponent() {
            return fruit::createComponent()
                .bind<fruit::Annotated<Annotation1, X>, fruit::Annotated<Annotation1, XImpl>>();
        }
        '''
    expect_success(COMMON_DEFINITIONS, source)

def test_required_const_forward_declared_success():
    source = '''
        struct X;
        using XFactory = std::function<std::unique_ptr<X>()>;
        struct Y {
            XFactory xFactory;

            INJECT(Y(XFactory xFactory))
                : xFactory(xFactory) {
            }

            void doStuff();
        };
        fruit::Component<fruit::Required<const XFactory>, Y> getYComponent() {
            return fruit::createComponent();
        }
        fruit::Component<const XFactory> getXFactoryComponent();
        fruit::Component<Y> getComponent() {
            return fruit::createComponent()
                .install(getYComponent)
                .install(getXFactoryComponent);
        }
        int main() {
            fruit::Injector<Y> injector(getComponent);
            Y* y(injector);
            y->doStuff();
        }

        // We define X as late as possible, to make sure that all the above compiles even if X is only forward-declared.
        struct X {
            virtual void foo() = 0;
            virtual ~X() = default;
        };
        void Y::doStuff() {
            xFactory()->foo();
        }
        struct XImpl : public X {
            INJECT(XImpl()) = default;
            void foo() override {}
        };
        fruit::Component<const XFactory> getXFactoryComponent() {
            return fruit::createComponent()
                .bind<X, XImpl>();
        }
        '''
    expect_success(COMMON_DEFINITIONS, source)

def test_required_const_annotated_forward_declared_success():
    source = '''
        struct X;
        using XFactory = std::function<std::unique_ptr<X>()>;
        using ConstXFactoryAnnot = fruit::Annotated<Annotation1, const XFactory>;
        struct Y {
            XFactory xFactory;

            INJECT(Y(ANNOTATED(Annotation1, XFactory) xFactory))
                : xFactory(xFactory) {
            }

            void doStuff();
        };
        fruit::Component<fruit::Required<ConstXFactoryAnnot>, Y> getYComponent() {
            return fruit::createComponent();
        }
        fruit::Component<ConstXFactoryAnnot> getXFactoryComponent();
        fruit::Component<Y> getComponent() {
            return fruit::createComponent()
                .install(getYComponent)
                .install(getXFactoryComponent);
        }
        int main() {
            fruit::Injector<Y> injector(getComponent);
            Y* y(injector);
            y->doStuff();
        }

        // We define X as late as possible, to make sure that all the above compiles even if X is only forward-declared.
        struct X {
            virtual void foo() = 0;
            virtual ~X() = default;
        };
        void Y::doStuff() {
            xFactory()->foo();
        }
        struct XImpl : public X {
            INJECT(XImpl()) = default;
            void foo() override {}
        };
        fruit::Component<ConstXFactoryAnnot> getXFactoryComponent() {
            return fruit::createComponent()
                .bind<fruit::Annotated<Annotation1, X>, fruit::Annotated<Annotation1, XImpl>>();
        }
        '''
    expect_success(COMMON_DEFINITIONS, source)

if __name__== '__main__':
    main(__file__)