tests/test_component_and_injector_params.py

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

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

    struct X {};
    struct Y {};

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

    struct Annotation2 {};
    using IntAnnot2 = fruit::Annotated<Annotation2, int>;
    using XAnnot2 = fruit::Annotated<Annotation2, X>;
    '''

@pytest.mark.parametrize('XAnnot,MaybeConstXAnnot', [
    ('X', 'X'),
    ('X', 'const X'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, X>'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, const X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
    'Injector',
])
def test_duplicate_type(XAnnot, MaybeConstXAnnot, Class):
    source = '''
        InstantiateType(fruit::Class<MaybeConstXAnnot, MaybeConstXAnnot>)
        '''
    expect_compile_error(
        'RepeatedTypesError<XAnnot,XAnnot>',
        'A type was specified more than once.',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('XAnnot,ConstXAnnot', [
    ('X', 'const X'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, const X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
    'Injector',
])
def test_duplicate_type_different_constness(XAnnot, ConstXAnnot, Class):
    source = '''
        InstantiateType(fruit::Class<XAnnot, ConstXAnnot>)
        '''
    expect_compile_error(
        'RepeatedTypesError<XAnnot,XAnnot>',
        'A type was specified more than once.',
        COMMON_DEFINITIONS,
        source,
        locals())

def test_duplicate_type_with_different_annotation_ok():
    source = '''
        fruit::Component<XAnnot1, XAnnot2> getComponent() {
          return fruit::createComponent()
            .registerConstructor<XAnnot1()>()
            .registerConstructor<XAnnot2()>();
        }

        int main() {
          fruit::Injector<XAnnot1, XAnnot2> injector1(getComponent);
          injector1.get<XAnnot1>();
          injector1.get<XAnnot2>();
          
          fruit::NormalizedComponent<XAnnot1, XAnnot2> normalizedComponent(getComponent);
          fruit::Injector<XAnnot1, XAnnot2> injector2(getComponent);
          injector2.get<XAnnot1>();
          injector2.get<XAnnot2>();
        }
        '''
    expect_success(
        COMMON_DEFINITIONS,
        source)

@pytest.mark.parametrize('XAnnot,MaybeConstXAnnot', [
    ('X', 'X'),
    ('X', 'const X'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, X>'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, const X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
])
def test_duplicate_type_in_required(XAnnot, MaybeConstXAnnot, Class):
    source = '''
        InstantiateType(fruit::Class<fruit::Required<MaybeConstXAnnot, MaybeConstXAnnot>>)
        '''
    expect_compile_error(
        'RepeatedTypesError<XAnnot,XAnnot>',
        'A type was specified more than once.',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('XAnnot,ConstXAnnot', [
    ('X', 'const X'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, const X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
])
def test_component_duplicate_type_in_required_different_constness(Class, XAnnot, ConstXAnnot):
    source = '''
        InstantiateType(fruit::Class<fruit::Required<XAnnot, ConstXAnnot>>)
        '''
    expect_compile_error(
        'RepeatedTypesError<XAnnot,XAnnot>',
        'A type was specified more than once.',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('XAnnot,MaybeConstXAnnot', [
    ('X', 'X'),
    ('X', 'const X'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, X>'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, const X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
])
def test_same_type_in_required_and_provided(XAnnot, MaybeConstXAnnot, Class):
    source = '''
        InstantiateType(fruit::Class<fruit::Required<MaybeConstXAnnot>, MaybeConstXAnnot>)
        '''
    expect_compile_error(
        'RepeatedTypesError<XAnnot,XAnnot>',
        'A type was specified more than once.',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('XAnnot,XAnnotInRequirements,XAnnotInProvides', [
    ('X', 'X', 'const X'),
    ('X', 'const X', 'X'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, const X>'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation1, const X>', 'fruit::Annotated<Annotation1, X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
])
def test_same_type_in_required_and_provided_different_constness(XAnnot, XAnnotInRequirements, XAnnotInProvides, Class):
    source = '''
        InstantiateType(fruit::Class<fruit::Required<XAnnotInRequirements>, XAnnotInProvides>)
        '''
    expect_compile_error(
        'RepeatedTypesError<XAnnot,XAnnot>',
        'A type was specified more than once.',
        COMMON_DEFINITIONS,
        source,
        locals())

def test_same_type_in_required_and_provided_different_annotation_ok():
    source = '''
        fruit::Component<fruit::Required<XAnnot1>, XAnnot2> getComponent() {
          return fruit::createComponent()
            .registerConstructor<XAnnot2()>();
        }
        
        fruit::Component<XAnnot1, XAnnot2> getRootComponent() {
          return fruit::createComponent()
              .install(getComponent)
              .registerConstructor<XAnnot1()>();
        }
        
        fruit::Component<> getEmptyComponent() {
          return fruit::createComponent();
        }
        
        int main() {
          fruit::Injector<XAnnot1, XAnnot2> injector1(getRootComponent);
          injector1.get<XAnnot1>();
          injector1.get<XAnnot2>();
          
          fruit::NormalizedComponent<XAnnot1, XAnnot2> normalizedComponent(getRootComponent);
          fruit::Injector<XAnnot1, XAnnot2> injector2(normalizedComponent, getEmptyComponent);
          injector2.get<XAnnot1>();
          injector2.get<XAnnot2>();
        }
        '''
    expect_success(
        COMMON_DEFINITIONS,
        source)

@pytest.mark.parametrize('XVariantAnnot,XVariantRegexp', [
    ('X*', 'X\*'),
    ('const X*', 'const X\*'),
    ('X&', 'X&'),
    ('const X&', 'const X&'),
    ('std::shared_ptr<X>', 'std::shared_ptr<X>'),
    ('fruit::Annotated<Annotation1, X*>', 'X\*'),
    ('fruit::Annotated<Annotation1, const X*>', 'const X\*'),
    ('fruit::Annotated<Annotation1, X&>', 'X&'),
    ('fruit::Annotated<Annotation1, const X&>', 'const X&'),
    ('fruit::Annotated<Annotation1, std::shared_ptr<X>>', 'std::shared_ptr<X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
    'Injector',
])
def test_error_non_class_type(XVariantAnnot, XVariantRegexp, Class):
    source = '''
        InstantiateType(fruit::Class<XVariantAnnot>)
        '''
    expect_compile_error(
        'NonClassTypeError<XVariantRegexp,X>',
        'A non-class type T was specified. Use C instead.',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('XVariantAnnot,XVariantRegexp', [
    ('const X', 'const X'),
    ('fruit::Annotated<Annotation1, const X>', 'const X'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
    'Injector',
])
def test_const_provided_type_ok(XVariantAnnot, XVariantRegexp, Class):
    source = '''
        InstantiateType(fruit::Class<XVariantAnnot>)
        '''
    expect_success(
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('XVariantAnnot,XVariantRegexp', [
    ('X*', 'X\*'),
    ('const X*', 'const X\*'),
    ('X&', 'X&'),
    ('const X&', 'const X&'),
    ('std::shared_ptr<X>', 'std::shared_ptr<X>'),
    ('fruit::Annotated<Annotation1, X*>', 'X\*'),
    ('fruit::Annotated<Annotation1, const X*>', 'const X\*'),
    ('fruit::Annotated<Annotation1, X&>', 'X&'),
    ('fruit::Annotated<Annotation1, const X&>', 'const X&'),
    ('fruit::Annotated<Annotation1, std::shared_ptr<X>>', 'std::shared_ptr<X>'),
])
@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
])
def test_error_non_class_type_in_requirements(XVariantAnnot, XVariantRegexp, Class):
    source = '''
        InstantiateType(fruit::Class<fruit::Required<XVariantAnnot>>)
        '''
    expect_compile_error(
        'NonClassTypeError<XVariantRegexp,X>',
        'A non-class type T was specified. Use C instead.',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('ConstZAnnot,ZAnnot', [
    ('const Z', 'Z'),
    ('fruit::Annotated<Annotation1, const Z>', 'fruit::Annotated<Annotation1, Z>'),
])
def test_const_class_type_ok(ConstZAnnot, ZAnnot):
    source = '''
        struct Z {};
        
        const Z z{};

        fruit::Component<ConstZAnnot> getComponent() {
          return fruit::createComponent()
              .bindInstance<ZAnnot, Z>(z);
        }
        
        fruit::Component<> getEmptyComponent() {
          return fruit::createComponent();
        }
        
        int main() {
          fruit::NormalizedComponent<ConstZAnnot> normalizedComponent(getComponent);
          fruit::Injector<ConstZAnnot> injector(normalizedComponent, getEmptyComponent);
          injector.get<ZAnnot>();
        }
        '''
    expect_success(
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('ConstZAnnot,ZAnnot', [
    ('const Z', 'Z'),
    ('fruit::Annotated<Annotation1, const Z>', 'fruit::Annotated<Annotation1, Z>'),
])
def test_const_class_type_in_requirements_ok(ConstZAnnot, ZAnnot):
    source = '''
        struct Z {};

        fruit::Component<fruit::Required<ConstZAnnot>> getComponent() {
          return fruit::createComponent();
        }
        
        const Z z{};
        
        fruit::Component<ConstZAnnot> getEmptyComponent() {
          return fruit::createComponent()
              .bindInstance<ZAnnot, Z>(z);
        }
        
        int main() {
          fruit::NormalizedComponent<fruit::Required<ConstZAnnot>> normalizedComponent(getComponent);
          fruit::Injector<ConstZAnnot> injector(normalizedComponent, getEmptyComponent);
          injector.get<ZAnnot>();
        }
        '''
    expect_success(
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
])
def test_two_required_lists_error(Class):
    source = '''
        InstantiateType(fruit::Class<fruit::Required<X>, fruit::Required<Y>>)
    '''
    expect_compile_error(
        'RequiredTypesInComponentArgumentsError<fruit::Required<Y>>',
        'A Required<...> type was passed as a non-first template parameter to fruit::Component or fruit::NormalizedComponent',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('Class', [
    'Component',
    'NormalizedComponent',
])
def test_required_list_not_first_argument_error(Class):
    source = '''
        InstantiateType(fruit::Class<X, fruit::Required<Y>>)
    '''
    expect_compile_error(
        'RequiredTypesInComponentArgumentsError<fruit::Required<Y>>',
        'A Required<...> type was passed as a non-first template parameter to fruit::Component or fruit::NormalizedComponent',
        COMMON_DEFINITIONS,
        source,
        locals())

def test_multiple_required_types_ok():
    source = '''
        fruit::Component<fruit::Required<X, Y>> getEmptyComponent() {
          return fruit::createComponent();
        }

        fruit::Component<X, Y> getComponent() {
          return fruit::createComponent()
              .install(getEmptyComponent)
              .registerConstructor<X()>()
              .registerConstructor<Y()>();
        }

        int main() {
          fruit::NormalizedComponent<fruit::Required<X, Y>> normalizedComponent(getEmptyComponent);
          fruit::Injector<X> injector(normalizedComponent, getComponent);
          injector.get<X>();
        }
    '''
    expect_success(
        COMMON_DEFINITIONS,
        source)

@pytest.mark.parametrize('XAnnot,YAnnot', [
    ('X', 'Y'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation2, Y>'),
])
def test_error_requirements_in_injector(XAnnot, YAnnot):
    source = '''
        InstantiateType(fruit::Injector<fruit::Required<YAnnot>, XAnnot>)
        '''
    expect_compile_error(
        'InjectorWithRequirementsError<YAnnot>',
        'Injectors can.t have requirements.',
        COMMON_DEFINITIONS,
        source,
        locals())

@pytest.mark.parametrize('XAnnot,YAnnot', [
    ('X', 'Y'),
    ('fruit::Annotated<Annotation1, X>', 'fruit::Annotated<Annotation2, Y>'),
])
def test_error_requirements_in_injector_second_argument(XAnnot, YAnnot):
    source = '''
        InstantiateType(fruit::Injector<XAnnot, fruit::Required<YAnnot>>)
        '''
    expect_compile_error(
        'InjectorWithRequirementsError<YAnnot>',
        'Injectors can.t have requirements.',
        COMMON_DEFINITIONS,
        source,
        locals())

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