lang/cs/Org.Apache.REEF.Tang.Tests/Injection/TestSetInjection.cs

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.

using System;
using System.Collections.Generic;
using System.Linq;
using Org.Apache.REEF.Tang.Annotations;
using Org.Apache.REEF.Tang.Formats;
using Org.Apache.REEF.Tang.Implementations.Tang;
using Org.Apache.REEF.Tang.Interface;
using Org.Apache.REEF.Tang.Util;
using Xunit;

namespace Org.Apache.REEF.Tang.Tests.Injection
{
    public interface INumber : IComparable
    {
    }

    public interface ITimeshift
    {
        string LinkId { get; }

        TimeSpan TimeshiftSpan { get; }
    }

    public class TestSetInjection
    {
        [Fact]
        public void TestStringInjectDefault()
        {
            Box b = (Box)TangFactory.GetTang().NewInjector().GetInstance(typeof(Box));

            ISet<string> actual = b.Numbers;

            ISet<string> expected = new HashSet<string>();
            expected.Add("one");
            expected.Add("two");
            expected.Add("three");

            Assert.True(actual.Contains("one"));
            Assert.True(actual.Contains("two"));
            Assert.True(actual.Contains("three"));
        }

        [Fact]
        public void TestStringInjectNoDefault()
        {
            BoxNoDefault b = (BoxNoDefault)TangFactory.GetTang().NewInjector().GetInstance(typeof(BoxNoDefault));
            ISet<string> actual = b.Numbers; 
            Assert.Equal(actual.Count, 0);
        }

        [Fact]
        public void TestStringInjectNoDefaultWithValue()
        {
            var cb = TangFactory.GetTang().NewConfigurationBuilder();
            cb.BindSetEntry<SetOfNumbersNoDefault, string>(GenericType<SetOfNumbersNoDefault>.Class, "123");
            BoxNoDefault b = (BoxNoDefault)TangFactory.GetTang().NewInjector(cb.Build()).GetInstance(typeof(BoxNoDefault));

            ISet<string> actual = b.Numbers;

            Assert.Equal(actual.Count, 1);
        }

        [Fact]
        public void TestObjectInjectDefault()
        {
            IInjector i = TangFactory.GetTang().NewInjector();
            i.BindVolatileInstance(GenericType<Integer>.Class, new Integer(42));
            i.BindVolatileInstance(GenericType<Float>.Class, new Float(42.0001f));
            ISet<INumber> actual = ((Pool)i.GetInstance(typeof(Pool))).Numbers;
            ISet<INumber> expected = new HashSet<INumber>();
            expected.Add(new Integer(42));
            expected.Add(new Float(42.0001f));

            Assert.True(actual.Contains(new Integer(42)));
            Assert.True(actual.Contains(new Float(42.0001f)));
            Assert.Equal(actual.Count, expected.Count);
        }

        [Fact]
        public void TestBindVolatileParameterForSet()
        {
            IInjector i = TangFactory.GetTang().NewInjector();
            ISet<INumber> numbers = new HashSet<INumber>();
            numbers.Add(new Integer(42));
            numbers.Add(new Float(42.0001f));
            i.BindVolatileParameter(GenericType<SetOfClasses>.Class, numbers);
            ISet<INumber> actual = ((Pool)i.GetInstance(typeof(Pool))).Numbers;

            Assert.True(actual.Contains(new Integer(42)));
            Assert.True(actual.Contains(new Float(42.0001f)));
        }

        [Fact]
        public void TestInjectionWithSetFromSameInterface()
        {
            IConfiguration c = TangFactory.GetTang()
                .NewConfigurationBuilder()
                .BindImplementation(GenericType<INumber>.Class, GenericType<PoolNumber>.Class)
                .Build();
          
            IInjector i = TangFactory.GetTang().NewInjector(c);
            ISet<INumber> numbers = new HashSet<INumber>();
            numbers.Add(new Integer(42));
            numbers.Add(new Float(42.0001f));
            i.BindVolatileParameter(GenericType<SetOfClasses>.Class, numbers);
            var actual = ((PoolNumber)i.GetInstance(typeof(INumber))).Numbers;
           
            Assert.True(actual.Contains(new Integer(42)));
            Assert.True(actual.Contains(new Float(42.0001f)));
        }

        [Fact]
        public void TestStringInjectBound()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();
            cb.BindSetEntry<SetOfNumbers, string>(GenericType<SetOfNumbers>.Class, "four");
            cb.BindSetEntry<SetOfNumbers, string>(GenericType<SetOfNumbers>.Class, "five");
            cb.BindSetEntry<SetOfNumbers, string>(GenericType<SetOfNumbers>.Class, "six");

            Box b = (Box)TangFactory.GetTang().NewInjector(cb.Build()).GetInstance(typeof(Box));
            ISet<string> actual = b.Numbers;
            ISet<string> expected = new HashSet<string>();
            expected.Add("four");
            expected.Add("five");
            expected.Add("six");

            Assert.True(actual.Contains("four"));
            Assert.True(actual.Contains("five"));
            Assert.True(actual.Contains("six"));
            Assert.Equal(actual.Count, expected.Count);
        }

        [Fact]
        public void TestObjectInjectBound()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();
            cb.BindSetEntry<SetOfClasses, Integer, INumber>(GenericType<SetOfClasses>.Class, GenericType<Integer>.Class);
            cb.BindSetEntry<SetOfClasses, Float, INumber>(GenericType<SetOfClasses>.Class, GenericType<Float>.Class);

            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());
            i.BindVolatileInstance(GenericType<Integer>.Class, new Integer(4));
            i.BindVolatileInstance(GenericType<Float>.Class, new Float(42.0001f));

            ISet<INumber> actual = i.GetInstance<Pool>().Numbers;
            ISet<INumber> expected = new HashSet<INumber>();
            expected.Add(new Integer(4));
            expected.Add(new Float(42.0001f));
            Assert.True(Utilities.Utilities.Equals<INumber>(actual, expected));
        }

        [Fact]
        public void TestSetOfClassBound()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();
            cb.BindSetEntry<SetOfClasses, Integer1, INumber>(GenericType<SetOfClasses>.Class, GenericType<Integer1>.Class)  // bind an impl to the interface of the set
              .BindNamedParameter<Integer1.NamedInt, int>(GenericType<Integer1.NamedInt>.Class, "4"); // bind parameter for the impl

            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());

            ISet<INumber> actual = i.GetInstance<Pool>().Numbers;
            ISet<INumber> expected = new HashSet<INumber>();
            expected.Add(new Integer1(4));

            Assert.True(Utilities.Utilities.Equals<INumber>(actual, expected));
        }

        [Fact]
        public void TestSetOfClassWithDefault()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();
            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());

            ISet<INumber> actual = i.GetInstance<Pool1>().Numbers;
            Assert.NotNull(actual);
        }

        [Fact]
        public void TestSetOfTimeshift()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();

            cb.BindSetEntry<SetOfTimeshifts, Timeshift, ITimeshift>(GenericType<SetOfTimeshifts>.Class, GenericType<Timeshift>.Class)
            .BindNamedParameter<Timeshift.TimeshiftLinkId, string>(GenericType<Timeshift.TimeshiftLinkId>.Class, "123")
            .BindNamedParameter<Timeshift.TimeshiftInTicks, long>(GenericType<Timeshift.TimeshiftInTicks>.Class, "10");

            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());

            ISet<ITimeshift> actual = i.GetInstance<SetofTimeShiftClass>().Timeshifts;
            Assert.True(actual.Count == 1);
        }

        [Fact]
        public void TestSetOfTimeshiftMultipleInstances()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();

            // when adding another Timeshift into the set for named parameter SetOfTimeshifts, it ends up the same entry. 
            cb.BindSetEntry<SetOfTimeshifts, Timeshift, ITimeshift>(GenericType<SetOfTimeshifts>.Class, GenericType<Timeshift>.Class);
            cb.BindSetEntry<SetOfTimeshifts, Timeshift, ITimeshift>(GenericType<SetOfTimeshifts>.Class, GenericType<Timeshift>.Class);
            cb.BindNamedParameter<Timeshift.TimeshiftLinkId, string>(GenericType<Timeshift.TimeshiftLinkId>.Class, "123")
            .BindNamedParameter<Timeshift.TimeshiftInTicks, long>(GenericType<Timeshift.TimeshiftInTicks>.Class, "10");

            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());

            ISet<ITimeshift> actual = i.GetInstance<SetofTimeShiftClass>().Timeshifts;
            Assert.True(actual.Count == 1);
        }

        [Fact]
        public void TestSetOfTimeshiftMultipleSubClasses()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();

            // Adding implementations from different subclasses
            cb.BindSetEntry<SetOfTimeshifts, Timeshift, ITimeshift>(GenericType<SetOfTimeshifts>.Class, GenericType<Timeshift>.Class);
            cb.BindSetEntry<SetOfTimeshifts, Timeshift1, ITimeshift>(GenericType<SetOfTimeshifts>.Class, GenericType<Timeshift1>.Class);

            cb.BindNamedParameter<Timeshift.TimeshiftLinkId, string>(GenericType<Timeshift.TimeshiftLinkId>.Class, "123")
            .BindNamedParameter<Timeshift.TimeshiftInTicks, long>(GenericType<Timeshift.TimeshiftInTicks>.Class, "10");

            cb.BindNamedParameter<Timeshift1.TimeshiftLinkId, string>(GenericType<Timeshift1.TimeshiftLinkId>.Class, "456")
            .BindNamedParameter<Timeshift1.TimeshiftInTicks, long>(GenericType<Timeshift1.TimeshiftInTicks>.Class, "20"); 

            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());

            ISet<ITimeshift> actual = i.GetInstance<SetofTimeShiftClass>().Timeshifts;
            Assert.True(actual.Count == 2);
        }

        [Fact]
        public void TestSetOfTimeshiftWithDefault()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();

            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());

            ISet<ITimeshift> actual = i.GetInstance<SetofTimeShiftClass>().Timeshifts;
            Assert.True(actual.Count == 1);
        }

        [Fact]
        public void TestSetOfTimeshiftWithEmptySet()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();

            IInjector i = TangFactory.GetTang().NewInjector(cb.Build());

            ISet<ITimeshift> actual = i.GetInstance<SetofTimeShiftClassWithoutDefault>().Timeshifts;
            Assert.True(actual.Count == 0);
        }        

        [Fact]
        public void TestObjectInjectRoundTrip()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();
            cb.BindSetEntry<SetOfClasses, Integer, INumber>(GenericType<SetOfClasses>.Class, GenericType<Integer>.Class);
            cb.BindSetEntry<SetOfClasses, Float, INumber>(GenericType<SetOfClasses>.Class, GenericType<Float>.Class);

            AvroConfigurationSerializer serializer = new AvroConfigurationSerializer();
            IConfiguration c2 = serializer.FromString(serializer.ToString(cb.Build()));

            IInjector i = TangFactory.GetTang().NewInjector(c2);
            i.BindVolatileInstance(GenericType<Integer>.Class, new Integer(4));
            i.BindVolatileInstance(GenericType<Float>.Class, new Float(42.0001f));

            ISet<INumber> actual = i.GetInstance<Pool>().Numbers;
            ISet<INumber> expected = new HashSet<INumber>();
            expected.Add(new Integer(4));
            expected.Add(new Float(42.0001f));
            Assert.True(Utilities.Utilities.Equals<INumber>(actual, expected));
        }

        [Fact]
        public void TestStringInjectRoundTrip()
        {
            ICsConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder();
            cb.BindSetEntry<SetOfNumbers, string>(GenericType<SetOfNumbers>.Class, "four");
            cb.BindSetEntry<SetOfNumbers, string>(GenericType<SetOfNumbers>.Class, "five");
            cb.BindSetEntry<SetOfNumbers, string>(GenericType<SetOfNumbers>.Class, "six");

            string s = ConfigurationFile.ToConfigurationString(cb.Build());
            ICsConfigurationBuilder cb2 = TangFactory.GetTang().NewConfigurationBuilder();
            ConfigurationFile.AddConfigurationFromString(cb2, s);

            ISet<string> actual =
                ((Box)TangFactory.GetTang().NewInjector(cb2.Build()).GetInstance(typeof(Box))).Numbers;

            Assert.True(actual.Contains("four"));
            Assert.True(actual.Contains("five"));
            Assert.True(actual.Contains("six"));
        }

        [Fact]
        public void TestDefaultAsClass()
        {
            IInjector i = TangFactory.GetTang().NewInjector();
            i.BindVolatileInstance(GenericType<Integer>.Class, new Integer(1));
            i.BindVolatileInstance(GenericType<Float>.Class, new Float(2f));
            ISet<INumber> actual =
                (ISet<INumber>)
                i.GetNamedInstance<SetOfClassesDefaultClass, ISet<INumber>>(GenericType<SetOfClassesDefaultClass>.Class);

            ISet<INumber> expected = new HashSet<INumber>();
            expected.Add(new Integer(1));
            Assert.Equal(expected.Count, actual.Count);
            Assert.True(actual.Contains(new Integer(1)));
        }

        [Fact]
        public void TestInjectionExtension()
        {
            IInjector i = TangFactory.GetTang().NewInjector();
            i.BindVolatileInstance<Integer>(new Integer(1));
            i.BindVolatileInstance<Float>(new Float(2f));
            ISet<INumber> actual =
                (ISet<INumber>)
                i.GetNamedInstance<SetOfClassesDefaultClass, ISet<INumber>>();

            ISet<INumber> expected = new HashSet<INumber>();
            expected.Add(new Integer(1));
            Assert.Equal(expected.Count, actual.Count);
            Assert.True(actual.Contains(new Integer(1)));
        }

        [NamedParameter(DefaultValues = new string[] { "one", "two", "three" })]
        public class SetOfNumbers : Name<ISet<string>>
        {
        }

        [NamedParameter]
        public class SetOfNumbersNoDefault : Name<ISet<string>>
        {
        }
        public class BoxNoDefault
        {
            [Inject]
            public BoxNoDefault([Parameter(typeof(SetOfNumbersNoDefault))] ISet<string> numbers)
            {
                this.Numbers = numbers;
            }

            public ISet<string> Numbers { get; set; }
        }

        public class Box
        {
            [Inject]
            public Box([Parameter(typeof(SetOfNumbers))] ISet<string> numbers)
            {
                this.Numbers = numbers;
            }

            public ISet<string> Numbers { get; set; }
        }

        [NamedParameter(DefaultClasses = new Type[] { typeof(Integer), typeof(Float) })]
        public class SetOfClasses : Name<ISet<INumber>>
        {
        }

        public class Pool
        {
            [Inject]
            private Pool([Parameter(typeof(SetOfClasses))] ISet<INumber> numbers)
            {
                this.Numbers = numbers;
            }

            public ISet<INumber> Numbers { get; set; }
        }

        public class PoolNumber : INumber
        {
            [Inject]
            private PoolNumber([Parameter(typeof(SetOfClasses))] ISet<INumber> numbers)
            {
                this.Numbers = numbers;
            }

            public ISet<INumber> Numbers { get; set; }

            public int CompareTo(object obj)
            {
                throw new NotImplementedException();
            }
        }

        [NamedParameter(DefaultClass = typeof(Integer))]
        public class SetOfClassesDefaultClass : Name<ISet<INumber>>
        {
        }

        public class Integer : INumber
        {
            private readonly int val;
          
            public Integer(int v)
            {
                val = v;
            }

            public int CompareTo(object obj)
            {
                if (!(obj is Integer))
                {
                    return -1;
                }
                if (this.val == ((Integer)obj).val)
                {
                    return 0;
                }

                if (this.val < ((Integer)obj).val)
                {
                    return -1;
                }

                return 1;
            }

            public override bool Equals(object obj)
            {
                if (!(obj is Integer))
                {
                    return false;
                }

                if (this.val == ((Integer)obj).val)
                {
                    return true;
                }

                return false;
            }

            public override int GetHashCode()
            {
                return val.GetHashCode();
            }
        }

        public class Float : INumber
        {
            private readonly float val;

            [Inject]
            public Float(float v)
            {
                val = v;
            }

            public int CompareTo(object obj)
            {
                if (!(obj is Float))
                {
                    return -1;
                }

                if (val == ((Float)obj).val)
                {
                    return 0;
                }

                if (val < ((Float)obj).val)
                {
                    return -1;
                }

                return 1;
            }

            public override bool Equals(object obj)
            {
                if (!(obj is Float))
                {
                    return false;
                }

                if (this.val == ((Float)obj).val)
                {
                    return true;
                }

                return false;
            }

            public override int GetHashCode()
            {
                return val.GetHashCode();
            }
        }
        
        public class Integer1 : INumber
        {
            private readonly int val;

            [Inject]
            public Integer1([Parameter(typeof(NamedInt))] int v)
            {
                val = v;
            }

            public int CompareTo(object obj)
            {
                if (!(obj is Integer1))
                {
                    return -1;
                }
                if (this.val == ((Integer1)obj).val)
                {
                    return 0;
                }

                if (this.val < ((Integer1)obj).val)
                {
                    return -1;
                }

                return 1;
            }

            public override bool Equals(object obj)
            {
                if (!(obj is Integer1))
                {
                    return false;
                }

                if (this.val == ((Integer1)obj).val)
                {
                    return true;
                }

                return false;
            }

            public override int GetHashCode()
            {
                return val.GetHashCode();
            }

            [NamedParameter]
            public class NamedInt : Name<int>
            {
            }
        }

        public class Integer2 : INumber
        {
            private readonly int val;

            [Inject]
            public Integer2()
            {
                val = 0;
            }

            public int CompareTo(object obj)
            {
                if (!(obj is Integer2))
                {
                    return -1;
                }
                if (this.val == ((Integer2)obj).val)
                {
                    return 0;
                }

                if (this.val < ((Integer2)obj).val)
                {
                    return -1;
                }

                return 1;
            }

            public override bool Equals(object obj)
            {
                if (!(obj is Integer2))
                {
                    return false;
                }

                if (this.val == ((Integer2)obj).val)
                {
                    return true;
                }

                return false;
            }

            public override int GetHashCode()
            {
                return val.GetHashCode();
            }
        }

        public class Integer3 : INumber
        {
            private readonly int val;

            [Inject]
            public Integer3([Parameter(typeof(NamedInt))] int v)
            {
                val = v;
            }

            public int CompareTo(object obj)
            {
                if (!(obj is Integer))
                {
                    return -1;
                }
                if (this.val == ((Integer3)obj).val)
                {
                    return 0;
                }

                if (this.val < ((Integer3)obj).val)
                {
                    return -1;
                }

                return 1;
            }

            public override bool Equals(object obj)
            {
                if (!(obj is Integer3))
                {
                    return false;
                }

                if (this.val == ((Integer3)obj).val)
                {
                    return true;
                }

                return false;
            }

            public override int GetHashCode()
            {
                return val.GetHashCode();
            }

            [NamedParameter]
            public class NamedInt : Name<int>
            {
            }
        }

        public class Float1 : INumber
        {
            private readonly float val;

            [Inject]
            public Float1([Parameter(typeof(NamedFloat))] float v)
            {
                val = v;
            }

            public int CompareTo(object obj)
            {
                if (!(obj is Float))
                {
                    return -1;
                }

                if (val == ((Float1)obj).val)
                {
                    return 0;
                }

                if (val < ((Float1)obj).val)
                {
                    return -1;
                }

                return 1;
            }

            public override bool Equals(object obj)
            {
                if (!(obj is Float1))
                {
                    return false;
                }

                if (this.val == ((Float1)obj).val)
                {
                    return true;
                }

                return false;
            }

            public override int GetHashCode()
            {
                return val.GetHashCode();
            }

            [NamedParameter]
            public class NamedFloat : Name<float>
            {
            }
        }

        public class Pool1
        {
            [Inject]
            private Pool1([Parameter(typeof(SetOfClasseWithDefault))] ISet<INumber> numbers)
            {
                this.Numbers = numbers;
            }

            public ISet<INumber> Numbers { get; set; }
        }

        [NamedParameter(DefaultClass = typeof(Integer2))]
        public class SetOfClasseWithDefault : Name<ISet<INumber>>
        {
        }
    }

    public class Timeshift : ITimeshift
    {
        [Inject]
        public Timeshift([Parameter(typeof(TimeshiftLinkId))] string linkId, [Parameter(typeof(TimeshiftInTicks))] long timeshiftInTicks)
        {
            this.LinkId = linkId;
            this.TimeshiftSpan = TimeSpan.FromTicks(timeshiftInTicks);
        }

        public string LinkId { get; private set; }

        public TimeSpan TimeshiftSpan { get; private set; }

        [NamedParameter("TimeshiftLinkId", "TimeshiftLinkId", "myid")]
        public class TimeshiftLinkId : Name<string>
        {
        }

        [NamedParameter("TimeshiftInTicks", "TimeshiftInTicks", "10")]
        public class TimeshiftInTicks : Name<long>
        {
        }
    }

    public class Timeshift1 : ITimeshift
    {
        [Inject]
        public Timeshift1([Parameter(typeof(TimeshiftLinkId))] string linkId, [Parameter(typeof(TimeshiftInTicks))] long timeshiftInTicks)
        {
            this.LinkId = linkId;
            this.TimeshiftSpan = TimeSpan.FromTicks(timeshiftInTicks);
        }

        public string LinkId { get; private set; }

        public TimeSpan TimeshiftSpan { get; private set; }

        [NamedParameter("TimeshiftLinkId1", "TimeshiftLinkId1", "myid")]
        public class TimeshiftLinkId : Name<string>
        {
        }

        [NamedParameter("TimeshiftInTicks1", "TimeshiftInTicks1", "10")]
        public class TimeshiftInTicks : Name<long>
        {
        }
    }

    [NamedParameter(DefaultClass = typeof(Timeshift))]
    public class SetOfTimeshifts : Name<ISet<ITimeshift>>
    {
    }

    public class SetofTimeShiftClass
    {
        [Inject]
        public SetofTimeShiftClass([Parameter(typeof(SetOfTimeshifts))] ISet<ITimeshift> timeshifts)
        {
            this.Timeshifts = timeshifts;
        }
    
        public ISet<ITimeshift> Timeshifts { get; set; }
    }
    [NamedParameter]
    public class SetOfTimeshiftsWithoutDefaultClass : Name<ISet<ITimeshift>>
    {
    }

    public class SetofTimeShiftClassWithoutDefault
    {
        [Inject]
        public SetofTimeShiftClassWithoutDefault([Parameter(typeof(SetOfTimeshiftsWithoutDefaultClass))] ISet<ITimeshift> timeshifts)
        {
            this.Timeshifts = timeshifts;
        }

        public ISet<ITimeshift> Timeshifts { get; set; }
    }
}