641 lines
30 KiB
C#
641 lines
30 KiB
C#
// 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);
|
|
}
|
|
|
|
}
|
|
}
|