public void DataTableTest() { var nonSerializableClasseDataTable = GeneralHelper.CopyToDataTable(NonSerializableClass.GenerateList()); TestSerialize(nonSerializableClasseDataTable); TestSerialize(nonSerializableClasseDataTable.DefaultView); var serializableClassDataTable = GeneralHelper.CopyToDataTable(SerializableClass.GenerateList()); TestSerialize(serializableClassDataTable); TestSerialize(serializableClassDataTable.DefaultView); var dt = new DataSet(); var addressTypeEntityCollection = MetaSingletons.MetaData.AddressType.ToEntityCollection(); addressTypeEntityCollection.CreateHierarchicalProjection(dt); TestSerialize(dt.Tables[0]); TestSerialize(dt.Tables[0].DefaultView); var addressTypeDataTable = GeneralHelper.CopyToDataTable(MetaSingletons.MetaData.AddressType); TestSerialize(addressTypeDataTable); TestSerialize(addressTypeDataTable.DefaultView); var enumerableRowCollection = addressTypeDataTable.AsEnumerable(); TestSerialize(enumerableRowCollection); TestSerialize(DataTableExtensions.CopyToDataTable(enumerableRowCollection)); }
private SerializableClass(SerializationInfo info) { field1 = info.GetInt32("field1"); field2 = info.GetString("field2"); subClass = info.GetValue <SerializableClass>("subClass"); field3 = info.GetValue <int?>("field3"); }
private void SaveTheName_Click(object sender, EventArgs e) { try { if (LearnedDataText.Text != "") { using (Stream LearnData = new FileStream(Property.DatFileFolderPath + LearnedDataText.Text + ".dat", FileMode.Create)) { SerializableClass sendData = new SerializableClass(); sendData.SendInputs = Property.inputs; sendData.SendOutputs = Property.outputs; BinaryFormatter binFormatter = new BinaryFormatter(); binFormatter.Serialize(LearnData, sendData); LearnData.Close(); } } else { MessageBox.Show("파일의 이름을 입력하시오."); } this.Close(); } catch { MessageBox.Show("오류 발생"); this.Close(); } }
public void SetUp() { member = new SerializableMember { ClassCoupling = 1, CylomaticComplexity = 2, LinesOfCode = 3, MissingDefaultCase = 4, Name = "member", NoFallthrough = 5, NumberOfParameters = 6 }; toSerialize = new SerializableClass { ClassCoupling = 1, CyclomaticComplexity = 2, DepthOfInheritance = 3, LinesOfCode = 4, NumberOfMethods = 5, Toxicity = 6, Name = "MyClass", CodeBag = new SerializeableCodeBag { Name = "MyNamespace" }, Members = new[] { member } }; }
public void TestSerializable(ByteOrder order) { var p = new SerializableClass { Age = TestSupport.RandomInt(), Name = TestSupport.RandomString() }; AssertSerialization(p, order); }
public void safe_deserializing_using_wrong_generic_type_returns_null() { var obj = new SerializableClass() { A = 1, B = "Labor omnia vincit" }; var buffer = SerializationUtils.Serialize(obj); var objDeserialized = SerializationUtils.DeserializeSafe<SerializableClass2>(buffer); Assert.IsNull(objDeserialized); }
public static IGameCommand StringToCommand(string msg) { SerializableClass ctype = JsonUtility.FromJson <SerializableClass>(msg); Type t = Type.GetType(ctype.GetClassName()); IGameCommand gc = (IGameCommand)JsonUtility.FromJson(msg, t); return(gc); }
public void TestSerializable(Endianness order) { var p = new SerializableClass { Age = TestUtils.RandomInt(), Name = TestUtils.RandomString() }; AssertSerialization(p, order); }
public void SerializeClassWithSubClass() { var c = new SerializableClass(33, "test1", new SerializableClass(783, "sub-1", null)); var c2 = Serialize(c); Assert.NotNull(c2); Assert.IsType <SerializableClass>(c2); }
public void DifferentItemTypesTest() { var listofNonSerializableClasses = SerializableClass.GenerateListWithBothSerializableClasses(); TestSerialize(listofNonSerializableClasses); TestSerialize(listofNonSerializableClasses.Distinct()); TestSerialize(listofNonSerializableClasses.ToBindingListView()); }
public void serialized_and_deserialized_objects_match() { var obj = new SerializableClass() { A = 1, B = "Works.." }; var buffer = SerializationUtils.Serialize(obj); var objDeserialized = SerializationUtils.Deserialize<SerializableClass>(buffer); Assert.AreEqual(obj.A, objDeserialized.A); Assert.AreEqual(obj.B, objDeserialized.B); }
public async Task TestCRUDAsync() { ISession s = OpenSession(); BasicSerializable ser = new BasicSerializable(); SerializableClass serClass = ser.SerializableProperty; await(s.SaveAsync(ser)); await(s.FlushAsync()); s.Close(); s = OpenSession(); ser = (BasicSerializable)await(s.LoadAsync(typeof(BasicSerializable), ser.Id)); Assert.IsNull(ser.Serial, "should have saved as null"); ser.Serial = ser.SerializableProperty; await(s.FlushAsync()); s.Close(); s = OpenSession(); ser = (BasicSerializable)await(s.LoadAsync(typeof(BasicSerializable), ser.Id)); Assert.IsTrue(ser.Serial is SerializableClass, "should have been a SerializableClass"); Assert.AreEqual(ser.SerializableProperty, ser.Serial, "SerializablePorperty and Serial should both be 5 and 'serialize me'"); IDictionary props = new Hashtable(); props["foo"] = "bar"; props["bar"] = "foo"; ser.Serial = props; await(s.FlushAsync()); props["x"] = "y"; await(s.FlushAsync()); s.Close(); s = OpenSession(); ser = (BasicSerializable)await(s.LoadAsync(typeof(BasicSerializable), ser.Id)); props = (IDictionary)ser.Serial; Assert.AreEqual("bar", props["foo"]); Assert.AreEqual("y", props["x"]); Assert.AreEqual(serClass, ser.SerializableProperty); ser.SerializableProperty._classString = "modify me"; await(s.FlushAsync()); s.Close(); s = OpenSession(); ser = (BasicSerializable)await(s.LoadAsync(typeof(BasicSerializable), ser.Id)); Assert.AreEqual("modify me", ser.SerializableProperty._classString); Assert.AreEqual("bar", props["foo"]); Assert.AreEqual("y", props["x"]); await(s.DeleteAsync(ser)); await(s.FlushAsync()); s.Close(); }
private void LoadBox_Click(object sender, EventArgs e) { if (selected == true) { int index = listBox1.SelectedIndex; //MessageBox.Show(Convert.ToString(index)); //MessageBox.Show(Property.DatFileNmae[index]); using (Stream LearnedData = new FileStream(@"dat\" + Property.DatFileNmae[index] + ".dat", FileMode.Open)) { // BinaryFormatter 클래스의 개체 생성 BinaryFormatter binFormatter = new BinaryFormatter(); // LearnedData 스트림에 연결된 파일에 저장된 개체를 불러오기 // Object 반환으로 인한 형변환 SerializableClass readData = binFormatter.Deserialize(LearnedData) as SerializableClass; Property.inputs = readData.SendInputs; Property.outputs = readData.SendOutputs; // sendData 스트림 닫기 LearnedData.Close(); Property.serialDataLoad = true; } frm.LearnDataSaveBox.Enabled = true; frm.ForwardBox.Enabled = true; frm.BackwardBox.Enabled = true; frm.NumberBox.Enabled = true; frm.RL_BackwardBox.Enabled = true; frm.RL_ForwardBox.Enabled = true; frm.RL_RunNumberBox.Enabled = true; frm.RL_LearnDataSaveBox.Enabled = true; } if (Property.KNNBox == false && Property.LosisticBox == true) { Property.logistic = new Logistic(); Property.logistic.CalculateLogistic(Property.inputs, Property.outputs); if (Property.CameraConected == true) { frm.RL_AotoRunBox.Enabled = true; frm.RL_StopAotoRunBox.Enabled = true; } } else if (Property.KNNBox == true && Property.LosisticBox == false) { if (Property.CameraConected == true) { frm.AutoRunBox.Enabled = true; frm.StopAutoRunBox.Enabled = true; } } Property.KNNBox = false; Property.LosisticBox = false; this.Close(); }
public void TestSerializableStackReference() { SerializableClass c = new SerializableClass() { MyInt = 2 }; TestIt(y => new int[c.MyInt + y], 4); }
static void Main(string[] args) { AppDomain ad = AppDomain.CreateDomain("OtherAppDomain"); MarshallByRefClass marshall = (MarshallByRefClass)ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "MarshallByRefClass"); SerializableClass serializable = (SerializableClass)ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "SerializableClass"); Console.WriteLine(marshall.WhatIsMyAppDomain()); Console.WriteLine(serializable.WhatIsMyAppDomain()); }
public void SerializableEnumerableTest() { var addressTypeEntityCollection = MetaSingletons.MetaData.AddressType.ToEntityCollection(); TestSerialize(addressTypeEntityCollection); TestShow(SerializableBaseClass.GenerateList()); TestSerialize(((IEntity)addressTypeEntityCollection.First()).CustomPropertiesOfType); TestShow(SerializableBaseClass2.GenerateListWithBothSerializableClasses()); TestShow(SerializableClass.GenerateList()); }
public void NonSerializedMarkerTest() { var obj1 = new SerializableClass(2, 3); var serializer = new FudgeSerializer(context); var msg = serializer.SerializeToMsg(obj1); var obj2 = (SerializableClass)serializer.Deserialize(msg); Assert.Equal(2, obj2.GetSerializableField()); Assert.Equal(0, obj2.GetNonserializableField()); }
public void NullSerializationTest() { IDictionary <int, object> dictionary = null; var serializable = new SerializableClass(dictionary); using (var ms = new MemoryStream()) { pofSerializer.Serialize(ms, serializable); ms.Position = 0; var copy = pofSerializer.Deserialize <SerializableClass>(ms); AssertNull(copy.Dictionary); } }
public EncryptHelperTests() { _sut = new SerializableClass { Prop1 = 5, Prop2 = "prop2", Props3 = new[] { 2.2, 3.4, 5.133 } }; }
public void EmptySerializationTest() { IDictionary <int, object> dictionary = new Dictionary <int, object>(); var serializable = new SerializableClass(dictionary); using (var ms = new MemoryStream()) { pofSerializer.Serialize(ms, serializable); ms.Position = 0; var copy = pofSerializer.Deserialize <SerializableClass>(ms); AssertNotNull(copy.Dictionary); AssertEquals(0, copy.Dictionary.Count); } }
public void TestInit() { this.testObject = new SerializableClass() { Field = 3, Field2 = "gosho", Field3 = new double[] { 1, 3.4, 5.1, -5.9, 1010101 } }; this.serializationCloning = new SerializationCloning<SerializableClass>(); this.serializationCloning2 = new SerializationCloning<NonSerializableClass>(); this.testObject2 = new NonSerializableClass(); }
public void ToXElement_Test() { XElement res; WrongSerializableClass empty = new WrongSerializableClass(); SerializableClass scl = new SerializableClass(); res = empty.ToXElement(); Assert.IsNull(res); res = scl.ToXElement(); Assert.IsNotNull(res); Assert.IsFalse(res.IsEmpty); Assert.IsTrue(res.HasElements); }
public void When_an_object_is_binary_serializable_it_should_succeed() { // Arrange var subject = new SerializableClass { Name = "John", Id = 2 }; // Act Action act = () => subject.Should().BeBinarySerializable(); // Assert act.Should().NotThrow(); }
internal static void Send(SerializableClass item, Socket client) { if (!client.Connected) { client.Connect(Server.LocalEndPoint); } using (var stream = new MemoryStream()) { try { Serializer.Serialize(stream, item); client.Send(stream.GetBuffer()); } catch (Exception ex) { } } }
public void ObjectValueSerializationTest() { IDictionary <int, object> dictionary = new Dictionary <int, object>(); dictionary.Add(3, new object()); var serializable = new SerializableClass(dictionary); using (var ms = new MemoryStream()) { pofSerializer.Serialize(ms, serializable); ms.Position = 0; var copy = pofSerializer.Deserialize <SerializableClass>(ms); AssertNotNull(copy.Dictionary); AssertEquals(1, copy.Dictionary.Count); AssertEquals(3, copy.Dictionary.Keys.First()); AssertEquals(typeof(object), copy.Dictionary.Values.First().GetType()); } }
public void Load(string filename) { if (File.Exists(Application.persistentDataPath + "/" + filename + ".sav")) { Debug.Log("Game loaded"); // Included until I fully implement loading var formatter = new BinaryFormatter(); FileStream file = File.Open(Application.persistentDataPath + "/" + filename + ".sav", FileMode.Open); testSerializableClass = (SerializableClass)formatter.Deserialize(file); file.Close(); // todo: Make this part more general so it can be used for the actual project. } else { Debug.Log("File did not exist."); } }
public void Xml_test() { var x = new XmlSerializer(typeof(List <SerializableClass>)); var s = new MemoryStream(); x.Serialize(s, SerializableClass.GenerateList()); var ds = new DataSet(); var addressTypeEntityCollection = MetaSingletons.MetaData.AddressType.ToEntityCollection(); addressTypeEntityCollection.CreateHierarchicalProjection(ds); var xml = ds.GetXml(); var xmlDoc = new XmlDocument(); xmlDoc.LoadXml(xml); TestSerialize(xmlDoc.FirstChild.ChildNodes); TestShow(xmlDoc.FirstChild.ChildNodes); }
public void TestRoundTripSerializableObject() { var instance = new SerializableClass(123, "456"); var stream = new MemoryStream(); var writer = new ObjectWriter(stream); writer.WriteValue(instance); writer.Dispose(); stream.Position = 0; var reader = new ObjectReader(stream); var instance2 = (SerializableClass)reader.ReadValue(); reader.Dispose(); Assert.NotNull(instance2); Assert.Equal(instance.X, instance2.X); Assert.Equal(instance.Y, instance2.Y); }
public void changepos() { string path1 = pathn; string filename = path1; string fromfile = File.ReadAllText(filename); SerializableClass sc = JsonUtility.FromJson <SerializableClass>(fromfile); if (sc.name == "myJet") { jetobject.transform.position = sc.position; jetobject.transform.rotation = sc.rotation; } if (sc.name == "myCar") { carobject.transform.position = sc.position; carobject.transform.rotation = sc.rotation; Vector3 position = new Vector3(205, 343, -235); GameObject duplicate = Instantiate(carobject, position, transform.rotation); } }
public void SetUp() { versionInfo = new SerializableClassVersionInfo { CommitMessage = "msg", FileName = "filename", TimeStamp = DateTime.Now }; member = new SerializableMember { ClassCoupling = 1, CylomaticComplexity = 2, LinesOfCode = 3, MissingDefaultCase = 4, Name = "member", NoFallthrough = 5, NumberOfParameters = 6 }; toSerialize = new SerializableClass { ClassCoupling = 1, CyclomaticComplexity = 2, DepthOfInheritance = 3, LinesOfCode = 4, NumberOfMethods = 5, Toxicity = 6, Name = "MyClass", CodeBag = new SerializeableCodeBag { Name = "MyNamespace" }, Meta = new[] { versionInfo }, Members = new[] { member } }; }
private void OnGUI() { if (GUI.Button(new Rect(10, 10, 150, 100), "Serialize")) { string fileName = "serializableClass.dat"; Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite); BinaryFormatter binFormat = new BinaryFormatter(); binFormat.Serialize(fStream, this.serializableClass); fStream.Close(); this.serializableClass.name = "yanliang"; Debug.Log("the class name is: " + this.serializableClass.name); } if (GUI.Button(new Rect(300, 10, 150, 100), "Deserialize")) { string fileName = "serializableClass.dat"; Stream fStream = new FileStream(fileName, FileMode.Open, FileAccess.Read); BinaryFormatter binFormat = new BinaryFormatter(); this.serializableClass = binFormat.Deserialize(fStream) as SerializableClass; fStream.Close(); this.serializableClass.name = "yanliang"; Debug.Log("after Deserialize the class name is: " + this.serializableClass.name); } }
public void Disply() { string text1 = File.ReadAllText(pathn); SerializableClass sc1 = JsonUtility.FromJson <SerializableClass>(text1); if (sc1.name == "myJet") { string dispStr = "Jet.json File Loaded" + " " + "\r\n"; dispStr = dispStr + "name of jet :" + " " + sc1.name + "\r\n"; dispStr = dispStr + "position of jet changed to:" + " " + sc1.position + "\r\n"; dispStr = dispStr + "Orientation of jet changed to:" + " " + sc1.rotation + "\r\n"; eText.text = dispStr; Debug.Log(dispStr); } if (sc1.name == "myCar") { string dispStr1 = "Car.json File Loaded" + " " + "\r\n"; dispStr1 = dispStr1 + "name of Car:" + " " + sc1.name + "\r\n"; dispStr1 = dispStr1 + "position of Car changed to" + " " + sc1.position + "\r\n"; dispStr1 = dispStr1 + "Orientation of Car changed to" + " " + sc1.rotation + "\r\n"; eText.text = dispStr1; Debug.Log(dispStr1); } }
public void unsafe_deserializing_using_wrong_generic_type_fails() { var obj = new SerializableClass() { A = 1, B = "Labor omnia vincit" }; var buffer = SerializationUtils.Serialize(obj); SerializationUtils.Deserialize<SerializableClass2>(buffer); }
// Use this for initialization void Start() { this.serializableClass = new SerializableClass("chenjiadong", 26, true); }
public SerializableClassAsConstructorArgument(SerializableClass serializableClass) { }
public void When_an_object_is_binary_serializable_it_should_succeed() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new SerializableClass { Name = "John" }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeBinarySerializable(); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
/// <summary> /// Tests whether serializable objects are passed easier than Marshalled things /// </summary> /// <param name="parameter"></param> public void SomeMethodWithSerializabeParameter(SerializableClass parameter) { //Do something with this class. string s = parameter.ToString(); return; }