public static void Test_Can_Serializer_Then_Deserialize_Most_Complex_Test_Possible()
{
//arrange
SerializerService serializer = new SerializerService();
TestEnum[] arrayOne = new TestEnum[] { TestEnum.Zero, TestEnum.One };
TestEnum[] arrayTwo = new TestEnum[3] {
TestEnum.Two, TestEnum.One, TestEnum.Zero
};
BasicWireDataContract WireDataContractNested = new BasicWireDataContract(8);
//act
serializer.RegisterType <VeryComplexType>();
serializer.Compile();
byte[] bytes = serializer.Serialize(new VeryComplexType(6, WireDataContractNested, arrayOne, arrayTwo));
Assert.NotNull(bytes);
Assert.False(bytes.Length == 0);
VeryComplexType message = serializer.Deserialize <VeryComplexType>(bytes);
//assert
Assert.NotNull(message);
//check fields
for (int i = 0; i < arrayOne.Length; i++)
{
Assert.AreEqual(arrayOne[i], message.testEnums[i], $"Failed for index {i}.");
}
for (int i = 0; i < arrayTwo.Length; i++)
{
Assert.AreEqual(arrayTwo[i], message.testEnumsAnother[i], $"Failed for index {i}.");
}
}
private static void NewMethod(Stopwatch watch, SerializerService serializer)
{
watch.Start();
serializer.RegisterType <PlayerCharacterDataModel>();
serializer.Compile();
watch.Stop();
}
public static void Test_Can_Deserialize_SeperatedCollection_Type()
{
Assert.Warn("TODO You must fix and reimplement seperated collection. It's not working fully as intended.");
return;
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType <TestSeperatedCollection>();
serializer.Compile();
//act
byte[] bytes = serializer.Serialize(new TestSeperatedCollection("Hello meep56!", 123456, new[] { 55523, 90, 2445, 63432, 6969 }));
TestSeperatedCollection deserialized = serializer.Deserialize <TestSeperatedCollection>(bytes);
//assert
Assert.NotNull(deserialized);
Assert.NotNull(deserialized.IntsChars);
Assert.AreEqual(5, deserialized.Size, "Expected the size to be the original collection size");
Assert.AreEqual(5, deserialized.IntsChars.Length, $"Expected the length of the collection to be the original length");
Assert.AreEqual("Hello meep56!", deserialized.TestString);
Assert.AreEqual(123456, deserialized.AnotherValue);
}
public void Test_Can_Deserialize_ReadToEnd_String_Type()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType <ReadToEndStringType>();
serializer.Compile();
//act
byte[] bytes = serializer.Serialize(new ReadToEndStringType(5, TestStrings));
ReadToEndStringType deserializer = serializer.Deserialize <ReadToEndStringType>(bytes);
Assert.NotNull(deserializer);
Assert.IsNotEmpty(deserializer.Strings);
Assert.AreEqual(5, deserializer.I);
Assert.AreEqual(TestStrings.Length, deserializer.Strings.Length);
//Check that there are null terminators
Assert.AreEqual(TestStrings.Length, bytes.Skip(4).Count(b => b == 0));
for (int i = 0; i < TestStrings.Length; i++)
{
Assert.AreEqual(TestStrings[i], deserializer.Strings[i]);
}
}
public void Test_Can_Serialize_Then_Deserializer_AuthSessionChallengeEvent_Vanilla_Payload()
{
//arrange
SerializerService otherService = new SerializerService();
otherService.RegisterType <SessionAuthChallengeEvent>();
SerializerService serializer = new SerializerService();
serializer.RegisterType <SessionAuthChallengeEvent_Vanilla>();
serializer.Compile();
otherService.Compile();
SerializerService lastserializer = new SerializerService();
lastserializer.RegisterType <SessionAuthChallengeEvent_Vanilla>();
lastserializer.Compile();
//act
byte[] bytes = lastserializer.Serialize(new SessionAuthChallengeEvent_Vanilla(new SessionAuthChallengeEventData(55, new byte[32])));
SessionAuthChallengeEvent_Vanilla payload = serializer.Deserialize <SessionAuthChallengeEvent_Vanilla>(bytes);
//assert
Assert.NotNull(bytes);
}
public void Test_Can_Serialize_Type_With_Complex_Array_Ignored_And_SendSize_Array_Succedding(int[] intArray)
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType <TestComplexOptionalFieldWithDisable>();
serializer.Compile();
//act
byte[] bytes = serializer.Serialize(new TestComplexOptionalFieldWithDisable(intArray));
TestComplexOptionalFieldWithDisable deserializerData = serializer.Deserialize <TestComplexOptionalFieldWithDisable>(bytes);
//assert
Assert.NotNull(bytes);
Assert.True(bytes.Length != 0);
//Check it's sizeof the element * length + the sendsize
Assert.True(bytes.Length == intArray.Length * sizeof(int) + sizeof(int));
Assert.NotNull(deserializerData);
for (int i = 0; i < intArray.Length; i++)
{
Assert.AreEqual(intArray[i], deserializerData.TestInts[i]);
}
}
public void Test_Can_Register_All_Concrete_Models(Type t)
{
//We have to do abit of a hack if it's a generic type
//We need a closed generic. DBCs usually are generic if they have strings
if (t.IsGenericTypeDefinition)
{
//TODO: Handle contraints better, causes throw and this is a hack to catch
//TODO: Support closing multiple type arg generics
//Assuming this can work, assuming all 1 generic param for now.
try
{
t = t.MakeGenericType(typeof(StringDBCReference));
}
catch (Exception e)
{
Assert.Inconclusive($"Cannot test Type: {t.Name} because closed generic could not be made. Maybe caused by constaints. Error: {e.Message}");
}
}
//arrange
SerializerService serializer = new SerializerService();
//assert
Assert.DoesNotThrow(() => serializer.RegisterType(t));
Assert.DoesNotThrow(() => serializer.Compile());
Assert.True(serializer.isTypeRegistered(t), $"Failed to register Type: {t.Name}");
}
private static async Task AsyncMain()
{
//While they're typing this let's build the serializer.
Task serializerReady = Task.Factory.StartNew(() =>
{
serializer.RegisterType <AdtFile>();
serializer.Compile();
}, TaskCreationOptions.LongRunning);
string adtName = Console.ReadLine();
if (String.IsNullOrEmpty(adtName) || !File.Exists(adtName))
{
throw new ArgumentException($"No adt file named {adtName} found in the directory.");
}
byte[] bytes = File.ReadAllBytes(adtName);
//wait for the serializer to compile
await serializerReady;
AdtFile adtFile = serializer.Deserialize <AdtFile>(bytes);
foreach (var chunk in adtFile)
{
Console.WriteLine(chunk.ToString());
}
Console.ReadKey();
}
private static INetworkSerializationService BuildClientSerializer()
{
SerializerService serializer = new SerializerService();
GamePacketMetadataMarker
.SerializableTypes
.Concat(GamePacketMetadataMarker.GamePacketPayloadTypes)
.Where(t => t != typeof(SMSG_CONTACT_LIST_PAYLOAD) && t != typeof(SMSG_SPELL_GO_Payload))
.ToList()
.ForEach(t => serializer.RegisterType(t));
//Register all unimplemented stubs
foreach (Type t in GamePacketStubMetadataMarker.GamePacketPayloadStubTypes.Where(t => GamePacketMetadataMarker.UnimplementedOperationCodes.Value.Contains(t.GetCustomAttribute <GamePayloadOperationCodeAttribute>().OperationCode)))
{
serializer.RegisterType(t);
}
//Also the header types
serializer.RegisterType <ServerPacketHeader>();
serializer.RegisterType <OutgoingClientPacketHeader>();
serializer.RegisterType <SMSG_CONTACT_LIST_DTO_PROXY>();
serializer.RegisterType <SMSG_SPELL_GO_DTO_PROXY>();
serializer.Compile();
return(new FreecraftCoreGladNetSerializerAdapter(serializer));
}
public void Test_Can_Link_PatchingUpOneDir()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.Link <PatchingInformationPayload, PSOBBPatchPacketPayloadServer>();
serializer.Compile();
}
public void Test_Can_Register_PatchingLoginRequestPayload()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType(typeof(PatchingLoginRequestPayload));
serializer.Compile();
}
public static void Test_Doesnt_Throw_On_Empty_Compile()
{
//arrange
SerializerService service = new SerializerService();
//assert
Assert.DoesNotThrow(() => service.Compile());
}
public void Test_Can_Register_AddedSize_String_Type()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType <TestAddedSizeStringType>();
serializer.Compile();
}
public static void Test_Can_Register_Compression_Marked_Class()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType <TestInt32ArrayCompression>();
serializer.Compile();
}
public static void Test_Can_Register_AuthProofResponse()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType <AuthPacketBaseTest>();
serializer.Link <AuthLogonProofResponse, AuthPacketBaseTest>();
serializer.Compile();
}
private static ISerializerService CreateNewSerializer()
{
SerializerService serializer = new SerializerService();
serializer.RegisterType <MapDatFormatGenericBodyModel <MapDataFormatObjectEntry> >();
serializer.RegisterType <NRelSectionsChunkModel>();
serializer.Compile();
return(serializer);
}
//TODO: We should use seperate assemblies that can build the desired serializers
private static INetworkSerializationService BuildServerSerializer()
{
SerializerService serializer = new SerializerService();
//This is slightly complicated
//But we need to register all the vanilla DTOs
//but we should also register all the wotlk DTOs that we don't have vanilla DTOs for
//This design will change in the future so that there is: wotlk, vanilla and shared libraries
//But right now this is how we have to do it until then
IReadOnlyCollection <NetworkOperationCode> codes = VanillaGamePacketMetadataMarker.UnimplementedOperationCodes.Value;
HashSet <NetworkOperationCode> opcodeSet = new HashSet <NetworkOperationCode>();
foreach (var opcode in codes)
{
opcodeSet.Add(opcode);
}
GamePacketStubMetadataMarker
.GamePacketPayloadStubTypes
.Where(t =>
{
NetworkOperationCode code = t.Attribute <GamePayloadOperationCodeAttribute>().OperationCode;
//if it's not a vanilla or shared packet
return(opcodeSet.Contains(code) && GamePacketMetadataMarker.UnimplementedOperationCodes.Value.Contains(code));
})
.Concat(GamePacketMetadataMarker.GamePacketPayloadTypes.Where(t => opcodeSet.Contains(t.Attribute <GamePayloadOperationCodeAttribute>().OperationCode)))
.Concat(VanillaGamePacketMetadataMarker.VanillaGamePacketPayloadTypes)
//TODO: Disable this when you need
.Where(t => t != typeof(SMSG_CONTACT_LIST_PAYLOAD) && t != typeof(SMSG_SPELL_GO_Payload))
.ToList()
.ForEach(t =>
{
if (!(typeof(IUnimplementedGamePacketPayload).IsAssignableFrom(t)))
{
Console.WriteLine($"Registering Type: {t.Name}");
}
serializer.RegisterType(t);
});
//Also the header types
serializer.RegisterType <ServerPacketHeader>();
serializer.RegisterType <OutgoingClientPacketHeader>();
//TODO: Uncomment for dumping
//serializer.RegisterType(typeof(SMSG_COMPRESSED_UPDATE_OBJECT_DTO_PROXY));
//serializer.RegisterType(typeof(SMSG_UPDATE_OBJECT_DTO_PROXY));
serializer.RegisterType <SMSG_CONTACT_LIST_DTO_PROXY>();
serializer.RegisterType <SMSG_SPELL_GO_DTO_PROXY>();
serializer.Compile();
return(new FreecraftCoreGladNetSerializerAdapter(serializer));
}
public static void Test_Can_Serialize_Readonly_Property()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType <TestWithReadonlyProperty>();
serializer.Compile();
//act
byte[] bytes = serializer.Serialize(new TestWithReadonlyProperty(5));
}
public static void Test_Cant_Polymorphic_Serialize_Null()
{
//arrange
SerializerService serializer = new SerializerService();
//act
serializer.RegisterType <WireDataContractTest>();
serializer.Compile();
Assert.Throws <InvalidOperationException>(() => serializer.Deserialize <WireDataContractTest>(serializer.Serialize(new WireDataContractTest(null, null))));
}
public static void Test_Serializer_Can_Register_Most_Complex_Type_Possible()
{
//arrange
SerializerService serializer = new SerializerService();
//act
serializer.RegisterType <VeryComplexType>();
serializer.Compile();
//assert
Assert.True(serializer.isTypeRegistered <VeryComplexType>());
}
public void Test_Can_Register_ReadToEnd_String_Type()
{
//arrange
SerializerService serializer = new SerializerService();
//assert
Assert.DoesNotThrow(() =>
{
serializer.RegisterType <ReadToEndStringType>();
serializer.Compile();
});
}
public void Test_Can_Register_CustomClass_ReadToEnd()
{
//arrange
SerializerService serializer = new SerializerService();
//assert
Assert.DoesNotThrow(() =>
{
serializer.RegisterType<ReadToEndCustomClassType>();
serializer.Compile();
});
}
public void Test_No_Stack_Overflow_On_Deserializing_Unknown_Type()
{
//arrange
SerializerService serializer = new SerializerService();
//don't register
serializer.Compile();
byte[] bytes = new byte[] { 55, 78 };
//assert
Assert.Throws <InvalidOperationException>(() => serializer.Deserialize <PSOBBPacketHeader>(bytes));
}
public void Test_Can_Register_All_Concrete_Payloads(Type t)
{
//arrange
SerializerService serializer = new SerializerService();
//assert
Assert.DoesNotThrow(() => serializer.RegisterType(t));
serializer.Compile();
Assert.True(serializer.isTypeRegistered(t), $"Failed to register Type: {t.Name}");
Assert.True(serializer.isTypeRegistered(typeof(TPayloadBaseType)), $"Base packet type wasn't registered.");
}
public void Test_Can_Register_PatchingUpOneDir()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType(typeof(PatchingInformationPayload));
serializer.RegisterType(typeof(PSOBBPatchPacketPayloadServer));
serializer.RegisterType(typeof(PSOBBPatchPacketPayloadServer));
serializer.RegisterType(typeof(PatchingInformationPayload));
serializer.RegisterType(typeof(PSOBBPatchPacketPayloadServer));
serializer.RegisterType(typeof(PatchingInformationPayload));
serializer.Compile();
}
public static void Test_String_Serializer_Serializes()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.Compile();
//act
string value = serializer.Deserialize <string>(serializer.Serialize("Hello!"));
//assert
Assert.AreEqual(value, "Hello!");
}
private static async Task AsyncMain()
{
SerializerService serializer = new SerializerService();
typeof(AuthLogonChallengeRequest).Assembly
.GetTypes()
.Where(t => typeof(AuthenticationServerPayload).IsAssignableFrom(t) || typeof(AuthenticationClientPayload).IsAssignableFrom(t))
.ToList()
.ForEach(t =>
{
serializer.RegisterType(t);
});
serializer.Compile();
//The auth server is encryptionless and headerless
IManagedNetworkClient <AuthenticationClientPayload, AuthenticationServerPayload> client = new DotNetTcpClientNetworkClient()
.AddHeaderlessNetworkMessageReading(new FreecraftCoreGladNetSerializerAdapter(serializer))
.For <AuthenticationServerPayload, AuthenticationClientPayload, IAuthenticationPayload>()
.Build()
.AsManaged(new ConsoleOutLogger("ConsoleLogger", LogLevel.All, true, false, false, null));
if (!await client.ConnectAsync("127.0.0.1", 3724))
{
Console.WriteLine("Failed to connect");
}
await client.SendMessage(new AuthLogonChallengeRequest(ProtocolVersion.ProtocolVersionTwo, GameType.WoW, ExpansionType.WrathOfTheLichKing, 3, 5,
ClientBuild.Wotlk_3_3_5a, PlatformType.x86, OperatingSystemType.Win, LocaleType.enUS,
IPAddress.Parse("127.0.0.1"), "Glader"));
while (true)
{
var response = (await client.ReadMessageAsync()).Payload;
Console.WriteLine("Recieved payload");
AuthenticationLogonChallengeResponseMessageHandler handler = new AuthenticationLogonChallengeResponseMessageHandler();
if (response is AuthLogonChallengeResponse challengeResponse)
{
Console.WriteLine($"Response: Valid: {challengeResponse.isValid} Result: {challengeResponse.Result} SRP: {challengeResponse.Challenge}");
await handler.HandleMessage(new DefaultPeerMessageContext <AuthenticationClientPayload>(client, client, new PayloadInterceptMessageSendService <AuthenticationClientPayload>(client, client)), challengeResponse);
}
else
{
Console.WriteLine($"Recieved Payload of Type: {response.GetType().Name}");
}
}
}
public void Test_Can_Serializer_ReadToEnd_String_Type()
{
//arrange
SerializerService serializer = new SerializerService();
serializer.RegisterType<ReadToEndCustomClassType>();
serializer.Compile();
//act
byte[] bytes = serializer.Serialize(new ReadToEndCustomClassType(5, TestStrings.Select(t => new TestReadToEndCustomClass(t, 5)).ToArray()));
Assert.NotNull(bytes);
Assert.IsNotEmpty(bytes);
Assert.True(bytes.Length > 4);
}
public static void Test_Serializer_Can_Read_Write_Type_With_EnumString_Field()
{
//arrange
SerializerService service = new SerializerService();
service.RegisterType <WireDataContractWithStringEnum>();
service.Compile();
//act
WireDataContractWithStringEnum testInstance = service.Deserialize <WireDataContractWithStringEnum>((service.Serialize <WireDataContractWithStringEnum>(new WireDataContractWithStringEnum(TestEnum.Something))));
//assert
Assert.AreEqual(testInstance.test, TestEnum.Something);
}
public static void Test_Can_Register_Type_With_Child_Types()
{
//arrange
SerializerService serializer = new SerializerService();
//act
serializer.RegisterType <WireDataContractTest>();
serializer.Compile();
//assert
Assert.True(serializer.isTypeRegistered <WireDataContractTest>());
Assert.True(serializer.isTypeRegistered <ChildTypeOne>());
Assert.True(serializer.isTypeRegistered <BaseTypeField>());
}