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