/// <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);
            }
        }

 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("Culture", culture);
        }

        public override void Deserialize(IXunitSerializationInfo data)
        {
            base.Deserialize(data);

            Initialize(data.GetValue<string>("Culture"));
        }

 public void Serialize(IXunitSerializationInfo info) {
     info.AddValue("testCase", _testCase);
     info.AddValue("suppressDebugFail", _suppressDebugFail);
 }

 public void Deserialize(IXunitSerializationInfo info) {
     _testCase = info.GetValue<IXunitTestCase>("testCase");
     _suppressDebugFail = info.GetValue<bool>("suppressDebugFail");
 }

 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);
 }

 /// <inheritdoc/>
 public void Serialize(IXunitSerializationInfo info)
 {
     info.AddValue("MethodName", Method.Name);
     info.AddValue("TestClass", TestClass);
 }

 public void Serialize(IXunitSerializationInfo info)
 {
     info.AddValue("IntValue", IntValue);
     info.AddValue("StringValue", StringValue);
 }

        public override void Deserialize(IXunitSerializationInfo data)
        {
            base.Deserialize(data);

            this.whiteSpacePreservation = data.GetValue<WhiteSpacePreservation>("WhiteSpacePreservation");
        }

        public override void Serialize(IXunitSerializationInfo data)
        {
            base.Serialize(data);

            data.AddValue("WhiteSpacePreservation", this.whiteSpacePreservation);
        }

 /// <inheritdoc/>
 public void Serialize(IXunitSerializationInfo info)
 {
     info.AddValue("TestCollection", TestCollection);
     info.AddValue("ClassAssemblyName", Class.Assembly.Name);
     info.AddValue("ClassTypeName", Class.Name);
 }

 public void Serialize(IXunitSerializationInfo info)
 {
     info.AddValue("FileName", FileName, typeof(string));
     info.AddValue("LineNumber", LineNumber, typeof(int?));
 }

 public override void Serialize(IXunitSerializationInfo data)
 {
     base.Serialize(data);
     data.AddValue(nameof(this.SkippingExceptionNames), this.SkippingExceptionNames);
 }