/// <inheritdoc/>
public override void Deserialize(IXunitSerializationInfo data)
{
VisualStudioVersion = data.GetValue<string>("VisualStudioVersion");
RootSuffix = data.GetValue<string>(SpecialNames.VsixAttribute.RootSuffix);
NewIdeInstance = data.GetValue<bool?>(SpecialNames.VsixAttribute.NewIdeInstance);
TimeoutSeconds = data.GetValue<int> (SpecialNames.VsixAttribute.TimeoutSeconds);
}
public override void Serialize(IXunitSerializationInfo data)
{
data.AddValue("VisualStudioVersion", VisualStudioVersion);
data.AddValue(SpecialNames.VsixAttribute.RootSuffix, RootSuffix);
data.AddValue(SpecialNames.VsixAttribute.NewIdeInstance, NewIdeInstance);
data.AddValue(SpecialNames.VsixAttribute.TimeoutSeconds, TimeoutSeconds);
}
/// <inheritdoc/>
public void Deserialize(IXunitSerializationInfo info)
{
TestClass = info.GetValue<ITestClass>("TestClass");
var methodName = info.GetValue<string>("MethodName");
Method = TestClass.Class.GetMethod(methodName, includePrivateMethod: true);
}
/// <inheritdoc/>
public void Deserialize(IXunitSerializationInfo info)
{
TestCollection = info.GetValue<ITestCollection>("TestCollection");
var assemblyName = info.GetValue<string>("ClassAssemblyName");
var typeName = info.GetValue<string>("ClassTypeName");
Class = Reflector.Wrap(SerializationHelper.GetType(assemblyName, typeName));
}
/// <inheritdoc/>
public void Deserialize(IXunitSerializationInfo info)
{
var assemblyPath = info.GetValue<string>("AssemblyPath");
var assembly = System.Reflection.Assembly.Load(new AssemblyName
{
Name = Path.GetFileNameWithoutExtension(assemblyPath)
});
ConfigFileName = info.GetValue<string>("ConfigFileName");
Assembly = Reflector.Wrap(assembly);
}
/// <inheritdoc/>
public virtual void Deserialize(IXunitSerializationInfo info)
{
DisplayName = info.GetValue<string>("DisplayName");
TestAssembly = info.GetValue<ITestAssembly>("TestAssembly");
UniqueID = Guid.Parse(info.GetValue<string>("UniqueID"));
var assemblyName = info.GetValue<string>("DeclarationAssemblyName");
var typeName = info.GetValue<string>("DeclarationTypeName");
if (!string.IsNullOrWhiteSpace(assemblyName) && !string.IsNullOrWhiteSpace(typeName))
CollectionDefinition = Reflector.Wrap(SerializationHelper.GetType(assemblyName, typeName));
}
/// <inheritdoc/>
public virtual void Serialize(IXunitSerializationInfo info)
{
info.AddValue("DisplayName", DisplayName);
info.AddValue("TestAssembly", TestAssembly);
info.AddValue("UniqueID", UniqueID.ToString());
if (CollectionDefinition != null)
{
info.AddValue("DeclarationAssemblyName", CollectionDefinition.Assembly.Name);
info.AddValue("DeclarationTypeName", CollectionDefinition.Name);
}
else
{
info.AddValue("DeclarationAssemblyName", null);
info.AddValue("DeclarationTypeName", null);
}
}
void IXunitSerializable.Serialize(IXunitSerializationInfo info) {
info.AddValue(nameof(Expression), Expression);
info.AddValue(nameof(Length), Length);
info.AddValue(nameof(NameCount), NameCount);
info.AddValue(nameof(AttrCount), AttrCount);
info.AddValue(nameof(SlotCount), SlotCount);
info.AddValue(nameof(Sorted), Sorted);
info.AddValue(nameof(Children), Children);
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("FileName", FileName, typeof(string));
info.AddValue("LineNumber", LineNumber, typeof(int?));
}
/// <inheritdoc/>
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("MethodName", Method.Name);
info.AddValue("TestClass", TestClass);
}
/// <inheritdoc/>
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("InnerTestCase", this.testCase);
}
public override void Serialize(IXunitSerializationInfo data)
{
base.Serialize(data);
data.AddValue("Culture", culture);
}
public void Deserialize(IXunitSerializationInfo info)
{
NoData = info.GetValue<MySerializableWithNoData>("NoData");
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue(nameof(Height), Height);
info.AddValue(nameof(Width), Width);
}
public override void Serialize(IXunitSerializationInfo info)
{
base.Serialize(info);
info.AddValue(nameof(Strength), Strength);
}
public override void Serialize(IXunitSerializationInfo info)
{
info.AddValue("width", this.Width);
info.AddValue("height", this.Height);
base.Serialize(info);
}
public void Deserialize(IXunitSerializationInfo info)
{
Height = info.GetValue <int>(nameof(Height));
Width = info.GetValue <int>(nameof(Width));
}
public override void Deserialize(IXunitSerializationInfo info)
{
this.Width = info.GetValue <int>("width");
this.Height = info.GetValue <int>("height");
base.Deserialize(info);
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("ExpectedValue", ExpectedValue);
}
public void Deserialize(IXunitSerializationInfo info)
{
ExpectedValue = info.GetValue <string>("ExpectedValue");
}
public virtual void Deserialize(IXunitSerializationInfo info)
{
info.AddValue(nameof(Length), Length);
info.AddValue(nameof(Name), Name);
info.AddValue(nameof(this.Lives), Lives);
}
public override void Serialize(IXunitSerializationInfo data)
{
base.Serialize(data);
data.AddValue(nameof(ThreadType), ThreadType.ToString());
}
public override void Deserialize(IXunitSerializationInfo data)
{
base.Deserialize(data);
this.whiteSpacePreservation = data.GetValue<WhiteSpacePreservation>("WhiteSpacePreservation");
}
public override void Deserialize(IXunitSerializationInfo data)
{
ThreadType = (ThreadType)Enum.Parse(typeof(ThreadType), data.GetValue <string>(nameof(ThreadType)));
base.Deserialize(data);
}
public void Serialize(IXunitSerializationInfo info) {
info.AddValue("testCase", _testCase);
info.AddValue("suppressDebugFail", _suppressDebugFail);
}
public void Deserialize(IXunitSerializationInfo info)
{
Definition = BsonDocument.Parse(info.GetValue <string>("Definition"));
Name = info.GetValue <string>("Name");
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("IntValue", IntValue);
info.AddValue("StringValue", StringValue);
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("Definition", Definition.ToString());
info.AddValue("Name", Name);
}
public void Deserialize(IXunitSerializationInfo info)
{
Value = info.GetValue<int>(nameof(Value));
}
public override void Deserialize(IXunitSerializationInfo info)
{
this.FilePath = info.GetValue <string>("path");
base.Deserialize(info); // must be called last
}
/// <inheritdoc/>
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("MethodName", Method.Name);
info.AddValue("TestClass", TestClass);
}
public override void Serialize(IXunitSerializationInfo info)
{
base.Serialize(info);
info.AddValue("path", this.FilePath);
}
public void Deserialize(IXunitSerializationInfo info)
{
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue(nameof(Data), Data, typeof(int));
}
void IXunitSerializable.Deserialize(IXunitSerializationInfo info) {
Expression = info.GetValue<string>(nameof(Expression));
Length = info.GetValue<int>(nameof(Length));
NameCount = info.GetValue<int>(nameof(NameCount));
AttrCount = info.GetValue<int>(nameof(AttrCount));
SlotCount = info.GetValue<int>(nameof(SlotCount));
Sorted = info.GetValue<bool>(nameof(Sorted));
Children = info.GetValue<object[][]>(nameof(Children));
}
public virtual void Serialize(IXunitSerializationInfo info)
{
this.Length = info.GetValue <double>(nameof(Length));
this.Name = info.GetValue <string>(nameof(Name));
this.Lives = info.GetValue <int>(nameof(Lives));
}
/// <inheritdoc/>
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("TestCollection", TestCollection);
info.AddValue("ClassAssemblyName", Class.Assembly.Name);
info.AddValue("ClassTypeName", Class.Name);
}
public override void Deserialize(IXunitSerializationInfo data)
{
base.Deserialize(data);
this.SkippingExceptionNames = data.GetValue<string[]>(nameof(this.SkippingExceptionNames));
}
public override void Serialize(IXunitSerializationInfo data)
{
base.Serialize(data);
data.AddValue("WhiteSpacePreservation", this.whiteSpacePreservation);
}
/// <inheritdoc/>
public void Deserialize(IXunitSerializationInfo info)
{
FileName = info.GetValue<string>("FileName");
LineNumber = info.GetValue<int?>("LineNumber");
}
public void Deserialize(IXunitSerializationInfo info)
{
Data = info.GetValue <int>(nameof(Data));
}
public override void Deserialize(IXunitSerializationInfo info)
{
this.Strength = info.GetValue <double>(nameof(Strength));
base.Deserialize(info);
}
public override void Serialize(IXunitSerializationInfo data)
{
base.Serialize(data);
data.AddValue(nameof(this.SkippingExceptionNames), this.SkippingExceptionNames);
}
/// <summary>
/// Used by XUnit.net for deserialization.
/// </summary>
/// <param name="serializationInfo">A parameter used by XUnit.net.</param>
public void Deserialize(IXunitSerializationInfo serializationInfo)
{
_testObject = serializationInfo.GetValue <string>(TestObjectKey);
}
/// <inheritdoc/>
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("FileName", FileName);
info.AddValue("LineNumber", LineNumber);
}
/// <summary>
/// Used by XUnit.net for serialization.
/// </summary>
/// <param name="serializationInfo">A parameter used by XUnit.net.</param>
public void Serialize(IXunitSerializationInfo serializationInfo)
{
serializationInfo.AddValue(TestObjectKey, _testObject);
}
public void Deserialize(IXunitSerializationInfo info) {
_testCase = info.GetValue<IXunitTestCase>("testCase");
_suppressDebugFail = info.GetValue<bool>("suppressDebugFail");
}
public void Deserialize(IXunitSerializationInfo info)
{
Object = JsonConvert.DeserializeObject <T>(info.GetValue <string>("objValue"));
}
public override void Deserialize(IXunitSerializationInfo data)
{
base.Deserialize(data);
Initialize(data.GetValue<string>("Culture"));
}
public void Serialize(IXunitSerializationInfo info)
{
var json = JsonConvert.SerializeObject(Object);
info.AddValue("objValue", json);
}
public void Deserialize(IXunitSerializationInfo info)
{
IntValue = info.GetValue<int>("IntValue");
StringValue = info.GetValue<string>("StringValue");
}
public override void Serialize(IXunitSerializationInfo data)
{
base.Serialize(data);
data.AddValue("MaxRetries", maxRetries);
}
public void Serialize(IXunitSerializationInfo info) { }
public override void Deserialize(IXunitSerializationInfo data)
{
base.Deserialize(data);
maxRetries = data.GetValue <int>("MaxRetries");
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue("NoData", NoData);
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue(nameof(_connectionString), _connectionString);
}
public void Serialize(IXunitSerializationInfo info)
{
info.AddValue(nameof(Value), Value);
}
/// <inheritdoc/>
public void Deserialize(IXunitSerializationInfo info)
{
this.testCase = info.GetValue <IXunitTestCase>("InnerTestCase");
}
public void Deserialize(IXunitSerializationInfo info)
{
_connectionString = info.GetValue <string>(nameof(_connectionString));
}
/// <inheritdoc/>
public void Deserialize(IXunitSerializationInfo data)
{
reflectionWrapper = new Xunit1ReflectionWrapper(
data.GetValue<string>("AssemblyFileName"),
data.GetValue<string>("TypeName"),
data.GetValue<string>("MethodName")
);
ConfigFileName = data.GetValue<string>("ConfigFileName");
DisplayName = data.GetValue<string>("DisplayName");
SkipReason = data.GetValue<string>("SkipReason");
SourceInformation = data.GetValue<SourceInformation>("SourceInformation");
Traits = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
var keys = data.GetValue<string[]>("Traits.Keys");
foreach (var key in keys)
Traits.Add(key, data.GetValue<string[]>(String.Format("Traits[{0}]", key)).ToList());
}
