lib/netstd/Tests/Thrift.Tests/DataModel/DeepCopy.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.Diagnostics;
using System.Linq;
using System.Text;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OptReqDefTest;
using Thrift.Collections;

namespace Thrift.Tests.DataModel
{
    // ReSharper disable once InconsistentNaming
    [TestClass]
    public class DeepCopyTests
    {
        [TestMethod]
        public void Test_Complex_DeepCopy()
        {
            var first = InitializeInstance(new RaceDetails());
            VerifyIdenticalContent(first, InitializeInstance(new RaceDetails()));

            var second = first.DeepCopy();
            VerifyIdenticalContent(first, second);
            ModifyInstance(second,0);
            VerifyDifferentContent(first, second);
            VerifyIdenticalContent(first, InitializeInstance(new RaceDetails()));

            var third = second.DeepCopy();
            VerifyIdenticalContent(second, third);
            ModifyInstance(third,0);
            VerifyDifferentContent(second, third);
            VerifyIdenticalContent(first, InitializeInstance(new RaceDetails()));
        }

        private RaceDetails? MakeNestedRaceDetails(int nesting)
        {
            if (++nesting > 1)
                return null;

            var instance = new RaceDetails();
            InitializeInstance(instance,nesting);
            return instance;
        }

        private jack? MakeNestedUnion(int nesting)
        {
            if (++nesting > 1)
                return null;

            var details = new RaceDetails();
            InitializeInstance(details,nesting);
            return new jack.nested_struct(details);
        }


        private RaceDetails InitializeInstance(RaceDetails instance, int nesting = 0)
        {
            // at init, we intentionally leave all non-required fields unset
            Assert.IsFalse(instance.__isset.opt_one);
            Assert.IsFalse(instance.__isset.opt_two);
            Assert.IsFalse(instance.__isset.opt_three);
            Assert.IsFalse(instance.__isset.opt_four);
            Assert.IsFalse(instance.__isset.opt_five);
            Assert.IsFalse(instance.__isset.opt_six);
            Assert.IsFalse(instance.__isset.opt_seven);
            Assert.IsFalse(instance.__isset.opt_eight);
            Assert.IsFalse(instance.__isset.opt_nine);

            // set all required to null/default
            instance.Req_one = default;
            instance.Req_two = default;
            instance.Req_three = default;
            Assert.IsNotNull(instance.Req_four);
            instance.Req_five = default;
            instance.Req_six = default;
            instance.Req_seven = default;
            instance.Req_eight = default;
            Assert.IsNotNull(instance.Req_nine);

            // leave non-required fields unset again
            Assert.IsFalse(instance.__isset.def_one);
            Assert.IsFalse(instance.__isset.def_two);
            Assert.IsFalse(instance.__isset.def_three);
            Assert.IsFalse(instance.__isset.def_four);
            Assert.IsFalse(instance.__isset.def_five);
            Assert.IsFalse(instance.__isset.def_six);
            Assert.IsFalse(instance.__isset.def_seven);
            Assert.IsFalse(instance.__isset.def_eight);
            Assert.IsFalse(instance.__isset.def_nine);

            // these should have IDL defaults set

            Assert.IsTrue(instance.__isset.opt_one_with_value);
            Assert.IsTrue(instance.__isset.opt_two_with_value);
            Assert.IsTrue(instance.__isset.opt_three_with_value);
            Assert.IsTrue(instance.__isset.opt_four_with_value);
            Assert.IsTrue(instance.__isset.opt_five_with_value);
            Assert.IsTrue(instance.__isset.opt_six_with_value);
            Assert.IsTrue(instance.__isset.opt_seven_with_value);
            Assert.IsTrue(instance.__isset.opt_eight_with_value);
            Assert.IsTrue(instance.__isset.opt_nine_with_value);

            Assert.AreEqual(instance.Req_one_with_value, (Distance)1);
            Assert.AreEqual(instance.Req_two_with_value, 2.22);
            Assert.AreEqual(instance.Req_three_with_value, 3);
            Assert.AreEqual(instance.Req_four_with_value, "four");
            Assert.AreEqual(new Guid("55555555-5555-5555-5555-000000000000"), instance.Req_five_with_value);

            Assert.IsTrue(instance.Req_six_with_value!.Count == 1);
            Assert.AreEqual(instance.Req_six_with_value[0], 6 );

            Assert.IsTrue(instance.Req_seven_with_value!.Count == 1);
            Assert.IsTrue(instance.Req_seven_with_value.Contains(7));

            Assert.IsTrue(instance.Req_eight_with_value!.Count == 1);
            Assert.IsTrue(instance.Req_eight_with_value[8] == 8);

            Assert.AreEqual("nine", Encoding.UTF8.GetString(instance.Req_nine_with_value!));

            Assert.IsTrue(instance.__isset.def_one_with_value);
            Assert.IsTrue(instance.__isset.def_two_with_value);
            Assert.IsTrue(instance.__isset.def_three_with_value);
            Assert.IsTrue(instance.__isset.def_four_with_value);
            Assert.IsTrue(instance.__isset.def_five_with_value);
            Assert.IsTrue(instance.__isset.def_six_with_value);
            Assert.IsTrue(instance.__isset.def_seven_with_value);
            Assert.IsTrue(instance.__isset.def_eight_with_value);
            Assert.IsTrue(instance.__isset.def_nine_with_value);

            instance.Last_of_the_mohicans = true;

            if (nesting < 2)
            {
                instance.Far_list = new List<Distance>() { Distance.foo, Distance.bar, Distance.baz };
                instance.Far_set = new HashSet<Distance>() { Distance.foo, Distance.bar, Distance.baz };
                instance.Far_map = new Dictionary<Distance, Distance>() { [Distance.foo] = Distance.foo, [Distance.bar] = Distance.bar, [Distance.baz] = Distance.baz };

                instance.Far_set_list = new HashSet<List<Distance>>() { new List<Distance>() { Distance.foo } };
                instance.Far_list_map_set = new List<Dictionary<sbyte, HashSet<Distance>>>() { new Dictionary<sbyte, HashSet<Distance>>() { [1] = new HashSet<Distance>() { Distance.baz } } };

                instance.Far_map_dist_to_rds = new Dictionary<Distance, List<RaceDetails>>() { [Distance.bar] = new List<RaceDetails>()  };
                var details = MakeNestedRaceDetails(nesting);
                if (details != null)
                    instance.Far_map_dist_to_rds[Distance.bar].Add(details);

                instance.Req_nested = MakeNestedRaceDetails(nesting);
                Assert.IsFalse(instance.__isset.opt_nested);
                Assert.IsFalse(instance.__isset.def_nested);

                instance.Req_union = MakeNestedUnion(nesting);
                Assert.IsFalse(instance.__isset.opt_union);
                Assert.IsFalse(instance.__isset.def_union);
            }

            instance.Triplesix = (Distance)666;

            return instance;
        }

        private void ModifyInstance(RaceDetails instance, int level)
        {
            if ((instance == null) || (++level > 4))
                return;

            instance.Opt_one = ModifyValue(instance.Opt_one);
            instance.Opt_two = ModifyValue(instance.Opt_two);
            instance.Opt_three = ModifyValue(instance.Opt_three);
            instance.Opt_four = ModifyValue(instance.Opt_four);
            instance.Opt_five = ModifyValue(instance.Opt_five);
            instance.Opt_six = ModifyValue(instance.Opt_six);
            instance.Opt_seven = ModifyValue(instance.Opt_seven);
            instance.Opt_eight = ModifyValue(instance.Opt_eight);
            instance.Opt_nine = ModifyValue(instance.Opt_nine);

            instance.Req_one = ModifyValue(instance.Req_one);
            instance.Req_two = ModifyValue(instance.Req_two);
            instance.Req_three = ModifyValue(instance.Req_three);
            instance.Req_four = ModifyValue(instance.Req_four);
            instance.Req_five = ModifyValue(instance.Req_five);
            instance.Req_six = ModifyValue(instance.Req_six);
            instance.Req_seven = ModifyValue(instance.Req_seven);
            instance.Req_eight = ModifyValue(instance.Req_eight);
            instance.Req_nine = ModifyValue(instance.Req_nine);

            instance.Def_one = ModifyValue(instance.Def_one);
            instance.Def_two = ModifyValue(instance.Def_two);
            instance.Def_three = ModifyValue(instance.Def_three);
            instance.Def_four = ModifyValue(instance.Def_four);
            instance.Def_five = ModifyValue(instance.Def_five);
            instance.Def_six = ModifyValue(instance.Def_six);
            instance.Def_seven = ModifyValue(instance.Def_seven);
            instance.Def_eight = ModifyValue(instance.Def_eight);
            instance.Def_nine = ModifyValue(instance.Def_nine);

            instance.Opt_one_with_value = ModifyValue(instance.Opt_one_with_value);
            instance.Opt_two_with_value = ModifyValue(instance.Opt_two_with_value);
            instance.Opt_three_with_value = ModifyValue(instance.Opt_three_with_value);
            instance.Opt_four_with_value = ModifyValue(instance.Opt_four_with_value);
            instance.Opt_five_with_value = ModifyValue(instance.Opt_five_with_value);
            instance.Opt_six_with_value = ModifyValue(instance.Opt_six_with_value);
            instance.Opt_seven_with_value = ModifyValue(instance.Opt_seven_with_value);
            instance.Opt_eight_with_value = ModifyValue(instance.Opt_eight_with_value);
            instance.Opt_nine_with_value = ModifyValue(instance.Opt_nine_with_value);

            instance.Req_one_with_value = ModifyValue(instance.Req_one_with_value);
            instance.Req_two_with_value = ModifyValue(instance.Req_two_with_value);
            instance.Req_three_with_value = ModifyValue(instance.Req_three_with_value);
            instance.Req_four_with_value = ModifyValue(instance.Req_four_with_value);
            instance.Req_five_with_value = ModifyValue(instance.Req_five_with_value);
            instance.Req_six_with_value = ModifyValue(instance.Req_six_with_value);
            instance.Req_seven_with_value = ModifyValue(instance.Req_seven_with_value);
            instance.Req_eight_with_value = ModifyValue(instance.Req_eight_with_value);
            instance.Req_nine_with_value = ModifyValue(instance.Req_nine_with_value);

            instance.Def_one_with_value = ModifyValue(instance.Def_one_with_value);
            instance.Def_two_with_value = ModifyValue(instance.Def_two_with_value);
            instance.Def_three_with_value = ModifyValue(instance.Def_three_with_value);
            instance.Def_four_with_value = ModifyValue(instance.Def_four_with_value);
            instance.Def_five_with_value = ModifyValue(instance.Def_five_with_value);
            instance.Def_six_with_value = ModifyValue(instance.Def_six_with_value);
            instance.Def_seven_with_value = ModifyValue(instance.Def_seven_with_value);
            instance.Def_eight_with_value = ModifyValue(instance.Def_eight_with_value);
            instance.Def_nine_with_value = ModifyValue(instance.Def_nine_with_value);

            instance.Last_of_the_mohicans = ModifyValue(instance.Last_of_the_mohicans);

            instance.Far_list = ModifyValue(instance.Far_list);
            instance.Far_set = ModifyValue(instance.Far_set);
            instance.Far_map = ModifyValue(instance.Far_map);

            instance.Far_set_list = ModifyValue(instance.Far_set_list);
            instance.Far_list_map_set = ModifyValue(instance.Far_list_map_set);
            instance.Far_map_dist_to_rds = ModifyValue(instance.Far_map_dist_to_rds, level);

            instance.Req_nested = ModifyValue(instance.Req_nested, level);
            instance.Opt_nested = ModifyValue(instance.Opt_nested, level);
            instance.Def_nested = ModifyValue(instance.Def_nested, level);

            instance.Req_union = ModifyValue(instance.Req_union, level);
            instance.Opt_union = ModifyValue(instance.Opt_union, level);
            instance.Def_union = ModifyValue(instance.Def_union, level);

            instance.Triplesix = ModifyValue(instance.Triplesix);
        }

        private jack? ModifyValue(jack? value, int level)
        {
            if (++level > 4)
                return value;

            if (value == null)
                value = MakeNestedUnion(0);
            Debug.Assert(value?.As_nested_struct != null);
            ModifyInstance(value.As_nested_struct, level);
            return value;
        }

        private RaceDetails? ModifyValue(RaceDetails? value, int level)
        {
            if (++level > 4)
                return value;

            if (value == null)
                value = new RaceDetails();
            ModifyInstance(value,level);
            return value;
        }

        private Dictionary<Distance, List<RaceDetails>> ModifyValue(Dictionary<Distance, List<RaceDetails>>? value, int level)
        {
            if (value == null)
                value = new Dictionary<Distance, List<RaceDetails>>();

            if (++level > 4)
                return value;

            var details = new RaceDetails();
            InitializeInstance(details);
            value[Distance.foo] = new List<RaceDetails>() { details };

            if (value.TryGetValue(Distance.bar, out var list) && (list.Count > 0))
            {
                ModifyInstance(list[0], level);
                //list.Add(null);  -- Thrift does not allow null values in containers
            }

            // Thrift does not allow null values in containers
            //value[Distance.baz] = null;

            return value;
        }

        private static List<Dictionary<sbyte, HashSet<Distance>>> ModifyValue(List<Dictionary<sbyte, HashSet<Distance>>>? value)
        {
            if (value == null)
                value = new List<Dictionary<sbyte, HashSet<Distance>>>();

            if (value.Count == 0)
                value.Add(new Dictionary<sbyte, HashSet<Distance>>());
            //else
            //value.Add(null); --Thrift does not allow null values in containers

            sbyte key = (sbyte)(value[0].Count + 10);
            if (value[0].Count == 0)
                value[0].Add(key, new HashSet<Distance>());
            //else
            //value[0].Add(key, null); --Thrift does not allow null values in containers

            foreach (var entry in value)
            {
                if (entry != null)
                {
                    foreach (var pair in entry)
                    {
                        if (pair.Value != null)
                        {
                            if (pair.Value.Contains(Distance.baz))
                                pair.Value.Remove(Distance.baz);
                            else
                                pair.Value.Add(Distance.baz);
                        }
                    }
                }
            }

            return value;
        }

        private static HashSet<List<Distance>> ModifyValue(HashSet<List<Distance>>? value)
        {
            if (value == null)
                value = new HashSet<List<Distance>>();

            if (value.Count == 0)
                value.Add(new List<Distance>());
            //else
            //value.Add(null); -- Thrift does not allow null values in containers

            foreach (var entry in value)
                if( entry != null)
                    entry.Add(Distance.baz);

            return value;
        }

        private static Dictionary<Distance, Distance> ModifyValue(Dictionary<Distance, Distance>? value)
        {
            if (value == null)
                value = new Dictionary<Distance, Distance>();
            value[Distance.foo] = value.ContainsKey(Distance.foo) ? ++value[Distance.foo] : Distance.foo;
            value[Distance.bar] = value.ContainsKey(Distance.bar) ? ++value[Distance.bar] : Distance.bar;
            value[Distance.baz] = value.ContainsKey(Distance.baz) ? ++value[Distance.baz] : Distance.baz;
            return value;
        }

        private static HashSet<Distance> ModifyValue(HashSet<Distance>? value)
        {
            if (value == null)
                value = new HashSet<Distance>();

            if (value.Contains(Distance.foo))
                value.Remove(Distance.foo);
            else
                value.Add(Distance.foo);

            if (value.Contains(Distance.bar))
                value.Remove(Distance.bar);
            else
                value.Add(Distance.bar);

            if (value.Contains(Distance.baz))
                value.Remove(Distance.baz);
            else
                value.Add(Distance.baz);

            return value;
        }

        private static List<Distance> ModifyValue(List<Distance>? value)
        {
            if (value == null)
                value = new List<Distance>();
            value.Add(Distance.foo);
            value.Add(Distance.bar);
            value.Add(Distance.baz);
            return value;
        }

        private static bool ModifyValue(bool value)
        {
            return !value;
        }

        private static Dictionary<sbyte, short> ModifyValue(Dictionary<sbyte, short>? value)
        {
            if (value == null)
                value = new Dictionary<sbyte, short>();
            value.Add((sbyte)(value.Count + 10), (short)value.Count);
            return value;
        }

        private static HashSet<long> ModifyValue(HashSet<long>? value)
        {
            if (value == null)
                value = new HashSet<long>();
            value.Add(value.Count+100);
            return value;
        }

        private static List<int> ModifyValue(List<int>? value)
        {
            if (value == null)
                value = new List<int>();
            value.Add(value.Count);
            return value;
        }

        private static byte[] ModifyValue(byte[]? value)
        {
            if (value == null)
                value = new byte[1] { 0 };
            if (value.Length > 0)
                value[0] = (value[0] < 0xFF) ? ++value[0] : (byte)0;
            else
                value = new byte[1] { 0 };
            return value;
        }

        private static string ModifyValue(string? value)
        {
            return value + "1";
        }

        private static Guid ModifyValue(Guid value)
        {
            return new Guid( ModifyValue(value.ToByteArray()));
        }

        private static double ModifyValue(double value)
        {
            return value + 1.1;
        }

        private static short ModifyValue(short value)
        {
            return ++value;
        }

        private static Distance ModifyValue(Distance value)
        {
            return ++value;
        }

        private static void VerifyDifferentContent(RaceDetails first, RaceDetails second)
        {
            Assert.AreNotEqual(first, second);

            Assert.AreNotEqual(first.Opt_two, second.Opt_two);
            Assert.AreNotEqual(first.Opt_three, second.Opt_three);
            Assert.AreNotEqual(first.Opt_four, second.Opt_four);
            Assert.IsFalse(TCollections.Equals(first.Opt_five, second.Opt_five));
            Assert.IsFalse(TCollections.Equals(first.Opt_six, second.Opt_six));
            Assert.IsFalse(TCollections.Equals(first.Opt_seven, second.Opt_seven));
            Assert.IsFalse(TCollections.Equals(first.Opt_eight, second.Opt_eight));
            Assert.IsFalse(TCollections.Equals(first.Opt_nine, second.Opt_nine));

            Assert.AreNotEqual(first.Req_one, second.Req_one);
            Assert.AreNotEqual(first.Req_two, second.Req_two);
            Assert.AreNotEqual(first.Req_three, second.Req_three);
            Assert.AreNotEqual(first.Req_four, second.Req_four);
            Assert.IsFalse(TCollections.Equals(first.Req_five, second.Req_five));
            Assert.IsFalse(TCollections.Equals(first.Req_six, second.Req_six));
            Assert.IsFalse(TCollections.Equals(first.Req_seven, second.Req_seven));
            Assert.IsFalse(TCollections.Equals(first.Req_eight, second.Req_eight));
            Assert.IsFalse(TCollections.Equals(first.Req_nine, second.Req_nine));

            Assert.AreNotEqual(first.Def_one, second.Def_one);
            Assert.AreNotEqual(first.Def_two, second.Def_two);
            Assert.AreNotEqual(first.Def_three, second.Def_three);
            Assert.AreNotEqual(first.Def_four, second.Def_four);
            Assert.IsFalse(TCollections.Equals(first.Def_five, second.Def_five));
            Assert.IsFalse(TCollections.Equals(first.Def_six, second.Def_six));
            Assert.IsFalse(TCollections.Equals(first.Def_seven, second.Def_seven));
            Assert.IsFalse(TCollections.Equals(first.Def_eight, second.Def_eight));
            Assert.IsFalse(TCollections.Equals(first.Def_nine, second.Def_nine));

            Assert.AreNotEqual(first.Opt_one_with_value, second.Opt_one_with_value);
            Assert.AreNotEqual(first.Opt_two_with_value, second.Opt_two_with_value);
            Assert.AreNotEqual(first.Opt_three_with_value, second.Opt_three_with_value);
            Assert.AreNotEqual(first.Opt_four_with_value, second.Opt_four_with_value);
            Assert.IsFalse(TCollections.Equals(first.Opt_five_with_value, second.Opt_five_with_value));
            Assert.IsFalse(TCollections.Equals(first.Opt_six_with_value, second.Opt_six_with_value));
            Assert.IsFalse(TCollections.Equals(first.Opt_seven_with_value, second.Opt_seven_with_value));
            Assert.IsFalse(TCollections.Equals(first.Opt_eight_with_value, second.Opt_eight_with_value));
            Assert.IsFalse(TCollections.Equals(first.Opt_nine_with_value, second.Opt_nine_with_value));

            Assert.AreNotEqual(first.Req_one_with_value, second.Req_one_with_value);
            Assert.AreNotEqual(first.Req_two_with_value, second.Req_two_with_value);
            Assert.AreNotEqual(first.Req_three_with_value, second.Req_three_with_value);
            Assert.AreNotEqual(first.Req_four_with_value, second.Req_four_with_value);
            Assert.IsFalse(TCollections.Equals(first.Req_five_with_value, second.Req_five_with_value));
            Assert.IsFalse(TCollections.Equals(first.Req_six_with_value, second.Req_six_with_value));
            Assert.IsFalse(TCollections.Equals(first.Req_seven_with_value, second.Req_seven_with_value));
            Assert.IsFalse(TCollections.Equals(first.Req_eight_with_value, second.Req_eight_with_value));
            Assert.IsFalse(TCollections.Equals(first.Req_nine_with_value, second.Req_nine_with_value));

            Assert.AreNotEqual(first.Def_one_with_value, second.Def_one_with_value);
            Assert.AreNotEqual(first.Def_two_with_value, second.Def_two_with_value);
            Assert.AreNotEqual(first.Def_three_with_value, second.Def_three_with_value);
            Assert.AreNotEqual(first.Def_four_with_value, second.Def_four_with_value);
            Assert.IsFalse(TCollections.Equals(first.Def_five_with_value, second.Def_five_with_value));
            Assert.IsFalse(TCollections.Equals(first.Def_six_with_value, second.Def_six_with_value));
            Assert.IsFalse(TCollections.Equals(first.Def_seven_with_value, second.Def_seven_with_value));
            Assert.IsFalse(TCollections.Equals(first.Def_eight_with_value, second.Def_eight_with_value));
            Assert.IsFalse(TCollections.Equals(first.Def_nine_with_value, second.Def_nine_with_value));

            Assert.AreNotEqual(first.Last_of_the_mohicans, second.Last_of_the_mohicans);

            Assert.IsFalse(TCollections.Equals(first.Far_list, second.Far_list));
            Assert.IsFalse(TCollections.Equals(first.Far_set, second.Far_set));
            Assert.IsFalse(TCollections.Equals(first.Far_map, second.Far_map));

            Assert.IsFalse(TCollections.Equals(first.Far_set_list, second.Far_set_list));
            Assert.IsFalse(TCollections.Equals(first.Far_list_map_set, second.Far_list_map_set));
            Assert.IsFalse(TCollections.Equals(first.Far_map_dist_to_rds, second.Far_map_dist_to_rds));

            Assert.AreNotEqual(first.Req_nested, second.Req_nested);
            Assert.AreNotEqual(first.Opt_nested, second.Opt_nested);
            Assert.AreNotEqual(first.Def_nested, second.Def_nested);

            Assert.AreNotEqual(first.Req_union, second.Req_union);
            Assert.AreNotEqual(first.Opt_union, second.Opt_union);
            Assert.AreNotEqual(first.Def_union, second.Def_union);

            Assert.AreNotEqual(first.Triplesix, second.Triplesix);
        }

        private static void VerifyIdenticalContent(RaceDetails first, RaceDetails second)
        {
            Assert.AreEqual(first, second);

            Assert.AreEqual(first.Opt_two, second.Opt_two);
            Assert.AreEqual(first.Opt_three, second.Opt_three);
            Assert.AreEqual(first.Opt_four, second.Opt_four);
            Assert.IsTrue(TCollections.Equals(first.Opt_five, second.Opt_five));
            Assert.IsTrue(TCollections.Equals(first.Opt_six, second.Opt_six));
            Assert.IsTrue(TCollections.Equals(first.Opt_seven, second.Opt_seven));
            Assert.IsTrue(TCollections.Equals(first.Opt_eight, second.Opt_eight));
            Assert.IsTrue(TCollections.Equals(first.Opt_nine, second.Opt_nine));

            Assert.AreEqual(first.Req_one, second.Req_one);
            Assert.AreEqual(first.Req_two, second.Req_two);
            Assert.AreEqual(first.Req_three, second.Req_three);
            Assert.AreEqual(first.Req_four, second.Req_four);
            Assert.IsTrue(TCollections.Equals(first.Req_five, second.Req_five));
            Assert.IsTrue(TCollections.Equals(first.Req_six, second.Req_six));
            Assert.IsTrue(TCollections.Equals(first.Req_seven, second.Req_seven));
            Assert.IsTrue(TCollections.Equals(first.Req_eight, second.Req_eight));
            Assert.IsTrue(TCollections.Equals(first.Req_nine, second.Req_nine));

            Assert.AreEqual(first.Def_one, second.Def_one);
            Assert.AreEqual(first.Def_two, second.Def_two);
            Assert.AreEqual(first.Def_three, second.Def_three);
            Assert.AreEqual(first.Def_four, second.Def_four);
            Assert.IsTrue(TCollections.Equals(first.Def_five, second.Def_five));
            Assert.IsTrue(TCollections.Equals(first.Def_six, second.Def_six));
            Assert.IsTrue(TCollections.Equals(first.Def_seven, second.Def_seven));
            Assert.IsTrue(TCollections.Equals(first.Def_eight, second.Def_eight));
            Assert.IsTrue(TCollections.Equals(first.Def_nine, second.Def_nine));

            Assert.AreEqual(first.Opt_one_with_value, second.Opt_one_with_value);
            Assert.AreEqual(first.Opt_two_with_value, second.Opt_two_with_value);
            Assert.AreEqual(first.Opt_three_with_value, second.Opt_three_with_value);
            Assert.AreEqual(first.Opt_four_with_value, second.Opt_four_with_value);
            Assert.IsTrue(TCollections.Equals(first.Opt_five_with_value, second.Opt_five_with_value));
            Assert.IsTrue(TCollections.Equals(first.Opt_six_with_value, second.Opt_six_with_value));
            Assert.IsTrue(TCollections.Equals(first.Opt_seven_with_value, second.Opt_seven_with_value));
            Assert.IsTrue(TCollections.Equals(first.Opt_eight_with_value, second.Opt_eight_with_value));
            Assert.IsTrue(TCollections.Equals(first.Opt_nine_with_value, second.Opt_nine_with_value));

            Assert.AreEqual(first.Req_one_with_value, second.Req_one_with_value);
            Assert.AreEqual(first.Req_two_with_value, second.Req_two_with_value);
            Assert.AreEqual(first.Req_three_with_value, second.Req_three_with_value);
            Assert.AreEqual(first.Req_four_with_value, second.Req_four_with_value);
            Assert.IsTrue(TCollections.Equals(first.Req_five_with_value, second.Req_five_with_value));
            Assert.IsTrue(TCollections.Equals(first.Req_six_with_value, second.Req_six_with_value));
            Assert.IsTrue(TCollections.Equals(first.Req_seven_with_value, second.Req_seven_with_value));
            Assert.IsTrue(TCollections.Equals(first.Req_eight_with_value, second.Req_eight_with_value));
            Assert.IsTrue(TCollections.Equals(first.Req_nine_with_value, second.Req_nine_with_value));

            Assert.AreEqual(first.Def_one_with_value, second.Def_one_with_value);
            Assert.AreEqual(first.Def_two_with_value, second.Def_two_with_value);
            Assert.AreEqual(first.Def_three_with_value, second.Def_three_with_value);
            Assert.AreEqual(first.Def_four_with_value, second.Def_four_with_value);
            Assert.IsTrue(TCollections.Equals(first.Def_five_with_value, second.Def_five_with_value));
            Assert.IsTrue(TCollections.Equals(first.Def_six_with_value, second.Def_six_with_value));
            Assert.IsTrue(TCollections.Equals(first.Def_seven_with_value, second.Def_seven_with_value));
            Assert.IsTrue(TCollections.Equals(first.Def_eight_with_value, second.Def_eight_with_value));
            Assert.IsTrue(TCollections.Equals(first.Def_nine_with_value, second.Def_nine_with_value));

            Assert.AreEqual(first.Last_of_the_mohicans, second.Last_of_the_mohicans);

            Assert.IsTrue(TCollections.Equals(first.Far_list, second.Far_list));
            Assert.IsTrue(TCollections.Equals(first.Far_set, second.Far_set));
            Assert.IsTrue(TCollections.Equals(first.Far_map, second.Far_map));

            Assert.IsTrue(TCollections.Equals(first.Far_set_list, second.Far_set_list));
            Assert.IsTrue(TCollections.Equals(first.Far_list_map_set, second.Far_list_map_set));
            Assert.IsTrue(TCollections.Equals(first.Far_map_dist_to_rds, second.Far_map_dist_to_rds));

            Assert.AreEqual(first.Req_nested, second.Req_nested);
            Assert.AreEqual(first.Opt_nested, second.Opt_nested);
            Assert.AreEqual(first.Def_nested, second.Def_nested);

            Assert.AreEqual(first.Req_union, second.Req_union);
            Assert.AreEqual(first.Opt_union, second.Opt_union);
            Assert.AreEqual(first.Def_union, second.Def_union);

            Assert.AreEqual(first.Triplesix, second.Triplesix);
        }

    }
}