public void PerformanceTransformTesting(Xtensive.Tuples.Tuple tuple1, Xtensive.Tuples.Tuple tuple2, Xtensive.Tuples.Tuple tuple3, Xtensive.Tuples.Tuple tuple4)
{
int count = IterationCount;
AdvancedComparerStruct <Xtensive.Tuples.Tuple> comparer = AdvancedComparerStruct <Xtensive.Tuples.Tuple> .Default;
comparer.Equals(tuple1, tuple2);
comparer.Equals(tuple1, tuple3);
comparer.Equals(tuple3, tuple4);
TestHelper.CollectGarbage();
using (new Measurement("O&O", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(tuple1, tuple2);
}
TestHelper.CollectGarbage();
using (new Measurement("O&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(tuple1, tuple3);
}
TestHelper.CollectGarbage();
using (new Measurement("W&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(tuple3, tuple4);
}
}
private void CombinedTest(int count)
{
Xtensive.Tuples.Tuple t = Xtensive.Tuples.Tuple.Create(1, 2L, 3, "4", (object)null);
TupleTest(t, count);
t = t.ToFastReadOnly();
TupleTest(t, count);
}
public void BaseTest()
{
Xtensive.Tuples.Tuple t = Xtensive.Tuples.Tuple.Create(1, "2", 3);
TestLog.Info("Original: {0}", t);
Xtensive.Tuples.Tuple rt = t.ToReadOnly(TupleTransformType.TransformedTuple);
TestLog.Info("Wrapper: {0}", rt);
Assert.AreEqual(t, rt);
t.SetValue(0, 2);
Assert.AreEqual(t, rt);
t.SetValue(0, 1);
AssertEx.Throws <NotSupportedException>(delegate {
rt.SetValue(0, 2);
});
Xtensive.Tuples.Tuple ct = t.ToReadOnly(TupleTransformType.Tuple);
TestLog.Info("Copy: {0}", ct);
Assert.AreEqual(t, ct);
t.SetValue(0, 2);
Assert.AreNotEqual(t, ct);
t.SetValue(0, 1);
AssertEx.Throws <NotSupportedException>(delegate {
ct.SetValue(0, 2);
});
}
public void PerformanceTest()
{
AdvancedComparerStruct <Xtensive.Tuples.Tuple> comparer = AdvancedComparerStruct <Xtensive.Tuples.Tuple> .Default;
Xtensive.Tuples.Tuple t = Xtensive.Tuples.Tuple.Create(1, 2);
Xtensive.Tuples.Tuple ct = t.ToRegular();
Xtensive.Tuples.Tuple wt = t.ToReadOnly(TupleTransformType.TransformedTuple);
Xtensive.Tuples.Tuple wtc = t.ToReadOnly(TupleTransformType.TransformedTuple);
int count = IterationCount;
comparer.Equals(t, ct);
comparer.Equals(t, wt);
comparer.Equals(wt, wtc);
TestHelper.CollectGarbage();
using (new Measurement("O&O", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(t, ct);
}
TestHelper.CollectGarbage();
using (new Measurement("O&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(t, wt);
}
TestHelper.CollectGarbage();
using (new Measurement("W&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(wt, wtc);
}
}
public void GetFieldStateTest()
{
Xtensive.Tuples.Tuple tuple = Xtensive.Tuples.Tuple.Create(typeof(string));
TupleFieldState fieldState = tuple.GetFieldState(0);
Assert.IsTrue(Enum.IsDefined(typeof(TupleFieldState), fieldState));
}
public new void CopyTest()
{
Random random = RandomManager.CreateRandom(SeedVariatorType.CallingMethod);
int loopCount = 10;
int offset = random.Next(fieldTypes.Length);
Type[] sourceTypes;
Type[] targetTypes = GetTestTypes(loopCount, out sourceTypes, offset);
Xtensive.Tuples.Tuple source = Xtensive.Tuples.Tuple.Create(sourceTypes);
Xtensive.Tuples.Tuple target = Xtensive.Tuples.Tuple.Create(targetTypes);
Xtensive.Tuples.Tuple sameTypeTarget = Xtensive.Tuples.Tuple.Create(sourceTypes);
PopulateData(sourceTypes, source);
PopulateData(targetTypes, target);
PopulateData(sourceTypes, sameTypeTarget);
int startingIndex = random.Next(fieldTypes.Length * loopCount / 3) + fieldTypes.Length;
int startingTargetIndex = (random.Next(loopCount / 4) + 1) * fieldTypes.Length + offset + startingIndex % fieldTypes.Length;
int count = random.Next(fieldTypes.Length * loopCount / 4);
source.CopyTo(target, startingIndex, startingTargetIndex, count);
AssertAreSame(source, target, startingIndex, startingTargetIndex, count);
source.CopyTo(sameTypeTarget, source.Count);
AssertAreSame(source, sameTypeTarget);
}
public void BaseTest()
{
Assert.AreEqual("TupleComparer", advancedComparer.Implementation.GetType().Name);
Xtensive.Tuples.Tuple tuple1 = Xtensive.Tuples.Tuple.Create(types1);
Xtensive.Tuples.Tuple tuple2 = Xtensive.Tuples.Tuple.Create(types2);
CheckComparisons(tuple1, tuple1, 0);
CheckComparisons(tuple1, tuple2, -1);
// Same length
tuple1 = Xtensive.Tuples.Tuple.Create(types1);
tuple2 = Xtensive.Tuples.Tuple.Create(types1);
CheckComparisons(tuple1, tuple2, 0);
tuple1.SetValue(1, "test"); // null-"test" null-null
CheckComparisons(tuple1, tuple2, 1);
tuple2.SetValue(1, "test"); // null-"test" null-"test"
CheckComparisons(tuple1, tuple2, 0);
tuple2.SetValue(1, null); // null-"test" null-null
CheckComparisons(tuple1, tuple2, 1);
tuple1.SetValue(0, 123); // 123-"test" null-null
CheckComparisons(tuple1, tuple2, 1);
tuple2.SetValue(0, 123); // 123-"test" 123-null
CheckComparisons(tuple1, tuple2, 1);
tuple2.SetValue(1, "test");
tuple1.SetValue(1, null); // 123-null 123-"test"
CheckComparisons(tuple1, tuple2, -1);
}
public void CopyToTest()
{
const int iterationCount = 10000000;
Random random = RandomManager.CreateRandom(SeedVariatorType.CallingMethod);
Xtensive.Tuples.Tuple tuple = Xtensive.Tuples.Tuple.Create(10, 20, 234.456f, 2345.34534d, "aaaaaaaaaaa", DateTime.Now);
var hashCode = tuple.GetHashCode();
var copy = tuple.CreateNew();
// Warmup
for (int i = 0; i < iterationCount / 10; i++)
{
tuple.CopyTo(copy);
}
// Actual run
TestHelper.CollectGarbage(true);
// TestLog.Info("Get ready...");
using (new Measurement("Copying tuples", MeasurementOptions.Log, iterationCount)) {
for (int i = 0; i < iterationCount; i++)
{
tuple.CopyTo(copy);
}
}
}
private static void InternalSetValue <T>(Xtensive.Tuples.Tuple tuple, int fieldIndex, Random random)
{
IInstanceGenerator <T> generator = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>();
T instance = generator.GetInstance(random);
tuple.SetValue(fieldIndex, instance);
}
public void BaseTest()
{
TestLog.InfoRegion("CutInTransform test");
TestLog.Info("Originals: {0}, {1}, index {2}", t1, t2, CutInIndex);
CutInTransform ct = new CutInTransform(false, CutInIndex, t1.Descriptor, t2.Descriptor);
CutInTransform ctro = new CutInTransform(true, CutInIndex, t1.Descriptor, t2.Descriptor);
Xtensive.Tuples.Tuple wt1 = ct.Apply(TupleTransformType.TransformedTuple, t1, t2);
TestLog.Info("Wrapper: {0}", wt1);
Xtensive.Tuples.Tuple ct1 = ct.Apply(TupleTransformType.Tuple, t1, t2);
TestLog.Info("Copy: {0}", ct1);
Xtensive.Tuples.Tuple wt2 = ctro.Apply(TupleTransformType.TransformedTuple, t1, t2);
Xtensive.Tuples.Tuple ct2 = ctro.Apply(TupleTransformType.Tuple, t1, t2);
Assert.AreEqual(wt1, wt2);
Assert.AreEqual(wt2, ct1);
Assert.AreEqual(ct1, ct2);
TestLog.InfoRegion("CutInTransform<T> test");
TestLog.Info("Originals: {0}, {1}, index {2}", t1, value, CutInIndex);
CutInTransform <string> ctt = new CutInTransform <string>(false, CutInIndex, t1.Descriptor);
CutInTransform <string> cttro = new CutInTransform <string>(true, CutInIndex, t1.Descriptor);
Xtensive.Tuples.Tuple wtt1 = ctt.Apply(TupleTransformType.TransformedTuple, t1, value);
TestLog.Info("Wrapper: {0}", wtt1);
Xtensive.Tuples.Tuple ctt1 = ctt.Apply(TupleTransformType.Tuple, t1, value);
TestLog.Info("Copy: {0}", ctt1);
Xtensive.Tuples.Tuple wtt2 = cttro.Apply(TupleTransformType.TransformedTuple, t1, value);
Xtensive.Tuples.Tuple ctt2 = cttro.Apply(TupleTransformType.Tuple, t1, value);
Assert.AreEqual(wtt1, wtt2);
Assert.AreEqual(wtt2, ctt1);
Assert.AreEqual(ctt1, ctt2);
}
private void ToFastReadOnlyTest(Xtensive.Tuples.Tuple t, int count)
{
for (int i = 0; i < count; i++)
{
t.ToFastReadOnly();
}
}
private void GetValueTest(Xtensive.Tuples.Tuple t, int count, int index)
{
for (int i = 0; i < count; i++)
{
TupleFieldState state;
t.GetValue(index, out state);
}
}
public void EmptyTupleTest()
{
Xtensive.Tuples.Tuple tuple1 = Xtensive.Tuples.Tuple.Create(new Type[] {});
Xtensive.Tuples.Tuple tuple2 = Xtensive.Tuples.Tuple.Create(new Type[] {});
CheckComparisons(tuple1, tuple2, 0);
CheckComparisons(tuple1, tuple1, 0);
}
public void DebugTest()
{
Xtensive.Tuples.Tuple tuple1 = Xtensive.Tuples.Tuple.Create(types1);
Xtensive.Tuples.Tuple tuple2 = Xtensive.Tuples.Tuple.Create(types2);
tuple1.SetValue(1, "test"); // null-"test" null-null-null
tuple2.SetValue(1, "test"); // null-"test" null-"test"-null
CheckComparisons(tuple1, tuple2, -1);;
}
public void BaseTest()
{
Xtensive.Tuples.Tuple t1 = Xtensive.Tuples.Tuple.Create(1, "2");
Xtensive.Tuples.Tuple t2 = Xtensive.Tuples.Tuple.Create(3, 4.0, "5");
TestLog.Info("Originals: {0}, {1}", t1, t2);
CombineTransform mt = new CombineTransform(false, t1.Descriptor, t2.Descriptor);
CombineTransform mtro = new CombineTransform(true, t1.Descriptor, t2.Descriptor);
Xtensive.Tuples.Tuple wt1 = mt.Apply(TupleTransformType.TransformedTuple, t1, t2);
TestLog.Info("Wrapper: {0}", wt1);
Xtensive.Tuples.Tuple ct1 = mt.Apply(TupleTransformType.Tuple, t1, t2);
TestLog.Info("Copy: {0}", ct1);
Xtensive.Tuples.Tuple wt2 = mt.Apply(TupleTransformType.TransformedTuple, t1, t2);
Xtensive.Tuples.Tuple ct2 = mt.Apply(TupleTransformType.Tuple, t1, t2);
Assert.AreEqual(wt1, wt2);
Assert.AreEqual(wt2, ct1);
Assert.AreEqual(ct1, ct2);
wt1.SetValue(2, 0);
Assert.AreEqual(t2.GetValue(0), wt1.GetValue(2));
Assert.AreEqual(wt1, wt2);
Assert.AreNotEqual(wt2, ct1);
Assert.AreEqual(ct1, ct2);
ct1.SetValue(2, 0);
Assert.AreEqual(t2.GetValue(0), ct1.GetValue(2));
Assert.AreEqual(wt1, wt2);
Assert.AreEqual(wt2, ct1);
Assert.AreNotEqual(ct1, ct2);
Xtensive.Tuples.Tuple wtro = mtro.Apply(TupleTransformType.TransformedTuple, t1, t2);
AssertEx.Throws <NotSupportedException>(delegate {
wtro.SetValue(2, 0);
});
CombineTransform mt3 = new CombineTransform(false, t1.Descriptor, t1.Descriptor, t1.Descriptor);
Xtensive.Tuples.Tuple wt3 = mt3.Apply(TupleTransformType.TransformedTuple, t1, t1, t1);
TestLog.Info("Wrapper: {0}", wt3);
Xtensive.Tuples.Tuple ct3 = mt3.Apply(TupleTransformType.Tuple, t1, t1, t1);
TestLog.Info("Copy: {0}", ct3);
t1.SetValue(0, 0);
Assert.AreEqual(wt3.GetValue(4), t1.GetValue(0));
t1.SetValue(0, 1);
CombineTransform mt4 = new CombineTransform(false, t1.Descriptor, t1.Descriptor, t1.Descriptor, t1.Descriptor);
Xtensive.Tuples.Tuple wt4 = mt4.Apply(TupleTransformType.TransformedTuple, t1, t1, t1, t1);
TestLog.Info("Wrapper: {0}", wt4);
Xtensive.Tuples.Tuple ct4 = mt4.Apply(TupleTransformType.Tuple, t1, t1, t1, t1);
TestLog.Info("Copy: {0}", ct4);
t1.SetValue(0, 0);
Assert.AreEqual(wt4.GetValue(6), t1.GetValue(0));
t1.SetValue(0, 1);
}
public void MainTest()
{
Xtensive.Tuples.Tuple source = Tuple.Create(1);
MapTransform transform = new MapTransform(true, TupleDescriptor.Create <byte, int, string>(), new[] { -1, 0 });
Xtensive.Tuples.Tuple result = transform.Apply(TupleTransformType.TransformedTuple, source);
Assert.AreEqual(TupleFieldState.Default, result.GetFieldState(0));
Assert.AreEqual(TupleFieldState.Available, result.GetFieldState(1));
Assert.AreEqual(TupleFieldState.Default, result.GetFieldState(2));
}
private static void TestTuple(Xtensive.Tuples.Tuple tuple)
{
Assert.IsFalse(tuple.GetFieldState(0).IsAvailable());
try {
tuple.GetFieldState(0).IsNull();
throw new AssertionException("Value is not available. No one knows if it is null or not.");
} catch (InvalidOperationException) {
}
tuple.SetValue(0, 1);
Assert.IsTrue(tuple.GetFieldState(0).IsAvailable());
Assert.IsFalse(tuple.GetFieldState(0).IsNull());
Assert.IsTrue(tuple.GetFieldState(0).HasValue());
Assert.AreEqual(1, tuple.GetValue(0));
Assert.AreEqual(1, tuple.GetValue <int>(0));
Assert.AreEqual(new int?(1), tuple.GetValue <int?>(0));
tuple.SetValue(0, null);
Assert.IsTrue(tuple.GetFieldState(0).IsAvailable());
Assert.IsTrue(tuple.GetFieldState(0).IsNull());
Assert.IsFalse(tuple.GetFieldState(0).HasValue());
Assert.AreEqual(null, tuple.GetValue(0));
Assert.AreEqual(null, tuple.GetValue <int?>(0));
tuple.SetValue <int?>(0, null);
Assert.IsTrue(tuple.GetFieldState(0).IsAvailable());
Assert.IsTrue(tuple.GetFieldState(0).IsNull());
Assert.IsFalse(tuple.GetFieldState(0).HasValue());
Assert.AreEqual(null, tuple.GetValue(0));
Assert.AreEqual(null, tuple.GetValue <int?>(0));
Assert.AreEqual(null, tuple.GetValueOrDefault(0));
Assert.AreEqual(null, tuple.GetValueOrDefault <int?>(0));
try {
tuple.GetValue(1);
throw new AssertionException("Value should not be available.");
} catch (InvalidOperationException) {
}
try {
tuple.GetValue <string>(2);
throw new AssertionException("Value should not be available.");
} catch (InvalidOperationException) {
}
try {
tuple.GetValue <byte>(0);
throw new AssertionException("Null reference or Invalid cast exception should be thrown.");
}
catch (NullReferenceException) {}
catch (InvalidCastException) {}
Assert.IsTrue(tuple.Equals(tuple));
}
protected static void PopulateData(IList <Type> types, Xtensive.Tuples.Tuple tuple)
{
Random random = RandomManager.CreateRandom(SeedVariatorType.CallingMethod);
MethodInfo setValueMethodGeneric =
typeof(TupleBehaviorTestBase).GetMethod("InternalSetValue", BindingFlags.NonPublic | BindingFlags.Static);
for (int fieldIndex = 0; fieldIndex < tuple.Count; fieldIndex++)
{
Type type = types[fieldIndex % types.Count];
MethodInfo setValueMethod = setValueMethodGeneric.MakeGenericMethod(type);
setValueMethod.Invoke(null, new object[] { tuple, fieldIndex, random });
}
}
private void GetAllValuesTest(Xtensive.Tuples.Tuple t, int count)
{
int fieldCount = t.Count;
for (int i = 0; i < count; i++)
{
for (int j = 0; j < fieldCount; j++)
{
TupleFieldState state;
t.GetValue(j, out state);
}
}
}
public void BasicTest()
{
Xtensive.Tuples.Tuple t = Xtensive.Tuples.Tuple.Create(TupleDescriptor.Create <string, int, string, TimeSpan, string, string>());
t.SetValue(0, string.Empty);
t.SetValue(2, "n\\a");
t.SetValue(3, new TimeSpan());
t.SetValue(4, null);
t.SetValue(5, "null");
var s = t.Format();
var tt = Xtensive.Tuples.Tuple.Parse(t.Descriptor, s);
Assert.AreEqual(t, tt);
}
private void CheckComparisons(Xtensive.Tuples.Tuple x, Xtensive.Tuples.Tuple y, int expectedResult)
{
expectedResult = Normalize(expectedResult);
bool boolResult = expectedResult == 0;
Assert.AreEqual(boolResult, x.Equals(y));
Assert.AreEqual(boolResult, equalityComparer.Equals(x, y));
Assert.AreEqual(boolResult, advancedComparer.Equals(x, y));
// Reverse
expectedResult *= -1;
Assert.AreEqual(boolResult, equalityComparer.Equals(y, x));
Assert.AreEqual(boolResult, y.Equals(x));
Assert.AreEqual(boolResult, advancedComparer.Equals(y, x));
}
private void TupleTest(Xtensive.Tuples.Tuple t, int count)
{
using (TestLog.InfoRegion("Testing {0}", t.GetType().GetShortName())) {
using (warmup ? null : new Measurement("GetAllValues", count * t.Count))
GetAllValuesTest(t, count);
for (int i = 0; i < t.Count; i++)
{
using (warmup ? null : new Measurement(string.Format(
"GetValue({0}) ({1})", i, t.Descriptor[i].GetShortName()),
count * t.Count))
GetValueTest(t, count, i);
}
using (warmup ? null : new Measurement("ToFastReadOnly", count))
ToFastReadOnlyTest(t, count);
}
}
public void CreateExistingTupleTest()
{
const int iterationCount = 10000000;
TupleDescriptor descriptor = TupleDescriptor.Create(typicalFieldTypes);
Xtensive.Tuples.Tuple tuple = Xtensive.Tuples.Tuple.Create(descriptor);
using (new Measurement("CreateNew", iterationCount))
for (int i = 0; i < iterationCount; i++)
{
tuple.CreateNew();
}
using (new Measurement("TupleDescriptor.CreateTuple", iterationCount))
for (int i = 0; i < iterationCount; i++)
{
Xtensive.Tuples.Tuple.Create(descriptor);
}
}
public void GeneratorTest()
{
const int fieldCount = 10;
const int iterationCount = 100;
int iteration = 0;
Random random = RandomManager.CreateRandom(SeedVariatorType.CallingMethod);
using (new Measurement("Random Tuple generation", iterationCount)) {
while (iteration++ < iterationCount)
{
IList <Type> fieldTypesList = new List <Type>();
for (int i = 0; i < fieldCount; i++)
{
fieldTypesList.Add(allFieldTypes[random.Next(allFieldTypes.Length)]);
}
TupleDescriptor descriptor = TupleDescriptor.Create(fieldTypesList);
Xtensive.Tuples.Tuple tuple = Xtensive.Tuples.Tuple.Create(descriptor);
}
}
}
public void PerformanceTest()
{
TestLog.InfoRegion("CutInTransform test");
CutInTransform mt = new CutInTransform(false, CutInIndex, t1.Descriptor, t1.Descriptor);
Xtensive.Tuples.Tuple wt1 = mt.Apply(TupleTransformType.TransformedTuple, t1, t1);
Xtensive.Tuples.Tuple wt2 = mt.Apply(TupleTransformType.TransformedTuple, t1, t1);
Xtensive.Tuples.Tuple ct1 = mt.Apply(TupleTransformType.Tuple, t1, t1);
Xtensive.Tuples.Tuple ct2 = mt.Apply(TupleTransformType.Tuple, t1, t1);
PerformanceTransformTesting(ct1, ct2, wt1, wt2);
TestLog.InfoRegion("CutInTransform<T> test");
CutInTransform <string> mtt = new CutInTransform <string>(false, CutInIndex, t1.Descriptor);
Xtensive.Tuples.Tuple wtt1 = mtt.Apply(TupleTransformType.TransformedTuple, t1, value);
Xtensive.Tuples.Tuple wtt2 = mtt.Apply(TupleTransformType.TransformedTuple, t1, value);
Xtensive.Tuples.Tuple ctt1 = mtt.Apply(TupleTransformType.Tuple, t1, value);
Xtensive.Tuples.Tuple ctt2 = mtt.Apply(TupleTransformType.Tuple, t1, value);
PerformanceTransformTesting(ctt1, ctt2, wtt1, wtt2);
}
public void PerformanceTest2()
{
AdvancedComparerStruct <Xtensive.Tuples.Tuple> comparer = AdvancedComparerStruct <Xtensive.Tuples.Tuple> .Default;
Xtensive.Tuples.Tuple t = Xtensive.Tuples.Tuple.Create(1);
CombineTransform mt = new CombineTransform(false, t.Descriptor, t.Descriptor, t.Descriptor, t.Descriptor);
SegmentTransform st = new SegmentTransform(false, mt.Descriptor, new Segment <int>(1, 2));
Xtensive.Tuples.Tuple wt1 = st.Apply(TupleTransformType.TransformedTuple, mt.Apply(TupleTransformType.TransformedTuple, t, t, t, t));
Xtensive.Tuples.Tuple wt2 = st.Apply(TupleTransformType.TransformedTuple, mt.Apply(TupleTransformType.TransformedTuple, t, t, t, t));
Xtensive.Tuples.Tuple ct1 = st.Apply(TupleTransformType.Tuple, mt.Apply(TupleTransformType.Tuple, t, t, t, t));
Xtensive.Tuples.Tuple ct2 = st.Apply(TupleTransformType.Tuple, mt.Apply(TupleTransformType.Tuple, t, t, t, t));
int count = IterationCount;
comparer.Equals(ct1, ct2);
comparer.Equals(ct1, wt1);
comparer.Equals(wt1, wt2);
TestHelper.CollectGarbage();
using (new Measurement("O&O", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(ct1, ct2);
}
TestHelper.CollectGarbage();
using (new Measurement("O&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(ct1, wt1);
}
TestHelper.CollectGarbage();
using (new Measurement("W&W", MeasurementOptions.Log, count))
for (int i = 0; i < count; i++)
{
comparer.Equals(wt1, wt2);
}
}
bool ManualEquals(Xtensive.Tuples.Tuple x, Xtensive.Tuples.Tuple y)
{
if (y != null)
{
TupleFieldState state;
TupleFieldState state2;
if (x == y)
{
return(true);
}
if (x.Descriptor != y.Descriptor)
{
return(false);
}
var flag = x.GetValue <int>(0, out state) == y.GetValue <int>(0, out state2);
if ((state == state2) && ((state != TupleFieldState.Available) || flag))
{
return(true);
}
}
return(false);
}
public void DifferentialTest()
{
TupleDescriptor descriptor = TupleDescriptor.Create(fieldTypes);
Xtensive.Tuples.Tuple t1 = Tuple.Create(descriptor);
Xtensive.Tuples.Tuple t2 = t1.Clone();
PopulateData(fieldTypes, t2, t1);
DifferentialTuple d = new DifferentialTuple(t1);
AssertAreSame(t1, d);
PopulateData(fieldTypes, t1, d);
AssertAreSame(t1, d);
DifferentialTuple c = (DifferentialTuple)d.Clone();
AssertAreSame(d, c);
d.Reset();
AssertAreSame(t2, d);
AssertAreSame(t1, c.ToRegular());
}
public void BaseTest()
{
Xtensive.Tuples.Tuple t = Xtensive.Tuples.Tuple.Create(1, "2", 3, 4.0);
TestLog.Info("Original: {0}", t);
SegmentTransform st = new SegmentTransform(false, t.Descriptor, new Segment <int>(1, 2));
SegmentTransform stro = new SegmentTransform(true, t.Descriptor, new Segment <int>(1, 2));
Xtensive.Tuples.Tuple wt1 = st.Apply(TupleTransformType.TransformedTuple, t);
TestLog.Info("Wrapper: {0}", wt1);
Xtensive.Tuples.Tuple ct1 = st.Apply(TupleTransformType.Tuple, t);
TestLog.Info("Copy: {0}", ct1);
Xtensive.Tuples.Tuple wt2 = st.Apply(TupleTransformType.TransformedTuple, t);
Xtensive.Tuples.Tuple ct2 = st.Apply(TupleTransformType.Tuple, t);
Assert.AreEqual(wt1, wt2);
Assert.AreEqual(wt2, ct1);
Assert.AreEqual(ct1, ct2);
wt1.SetValue(1, 1);
Assert.AreEqual(t.GetValue(2), wt1.GetValue(1));
Assert.AreEqual(wt1, wt2);
Assert.AreNotEqual(wt2, ct1);
Assert.AreEqual(ct1, ct2);
ct1.SetValue(1, 1);
Assert.AreEqual(t.GetValue(2), ct1.GetValue(1));
Assert.AreEqual(wt1, wt2);
Assert.AreEqual(wt2, ct1);
Assert.AreNotEqual(ct1, ct2);
Xtensive.Tuples.Tuple wtro = stro.Apply(TupleTransformType.TransformedTuple, t);
AssertEx.Throws <NotSupportedException>(delegate {
wtro.SetValue(1, 1);
});
}
protected virtual Xtensive.Tuples.Tuple CreateTestTuple(Xtensive.Tuples.Tuple source)
{
return(source);
}
