public void Decode_ABC_to_BCD_with_key_1()
{
/* Тестирование по 3-м ААА
* А arrange
* А act
* А assert */
#region Arrange
var str = "BCD";
var expected_result = "ABC";
var key = 1;
#endregion
#region Act
var actual_result = StringEncoder.Decode(str, key);
#endregion
#region Assert
Assert.AreEqual(expected_result, actual_result);
#endregion
}
static async Task RunServerAsync(int port)
{
var bossGroup = new MultithreadEventLoopGroup(1);
var workerGroup = new MultithreadEventLoopGroup();
var stringEncoder = new StringEncoder();
var stringDecoder = new StringDecoder();
var serverHandler = new ServerHandler(GameCore);
try
{
var bootstrap = new ServerBootstrap();
bootstrap
.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>()
.Option(ChannelOption.SoBacklog, 100)
.Handler(new LoggingHandler(LogLevel.INFO))
.ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel =>
{
var pipeline = channel.Pipeline;
pipeline.AddLast(new DelimiterBasedFrameDecoder(8192, Delimiters.LineDelimiter()));
pipeline.AddLast(stringEncoder, stringDecoder, serverHandler);
}));
var bootstrapChannel = await bootstrap.BindAsync(port);
GameCore.RunContainers();
await bootstrapChannel.CloseAsync();
}
finally
{
Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync());
}
}
static async Task RunServerAsync()
{
var bossGroup = new MultithreadEventLoopGroup(1);
var workerGroup = new MultithreadEventLoopGroup();
var STRING_ENCODER = new StringEncoder();
var STRING_DECODER = new StringDecoder();
var SERVER_HANDLER = new ChatServerHandler();
try
{
var bootstrap = new ServerBootstrap();
bootstrap
.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>()
.Option(ChannelOption.SoBacklog, 100)
.Handler(new LoggingHandler(LogLevel.INFO))
.ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast(new DelimiterBasedFrameDecoder(8192, Delimiters.LineDelimiter()));
pipeline.AddLast(STRING_ENCODER, STRING_DECODER, SERVER_HANDLER);
}));
IChannel bootstrapChannel = await bootstrap.BindAsync(8080);
Console.ReadLine();
await bootstrapChannel.CloseAsync();
}
finally
{
Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync());
}
}
public void send_message()
{
var slice = new BufferSlice(new byte[65535], 0, 65535);
var encoder = new StringEncoder();
var decoder = new StringDecoder();
var sut = CreateClientChannel(slice, encoder, decoder);
sut.MessageReceived += (channel, message) =>
{
};
var stream = new SslStream(new NetworkStream(_helper.Server));
stream.BeginAuthenticateAsServer(_certificate, OnAuthenticated, stream);
sut.Assign(_helper.Client);
sut.Send("Hello world");
//i do not know why this loop is required.
//for some reason the send message is divided into two tcp packets
//when using SslStream.
var bytesReceived = 0;
var buf = new byte[65535];
while (bytesReceived < 15)
{
bytesReceived += stream.Read(buf, bytesReceived, 15);
}
var actual = Encoding.ASCII.GetString(buf, 4, bytesReceived - 4); // string encoder have a length header.
actual.Should().Be("Hello world");
}
public bool Initialize()
{
Log?.Verbose(className, "Initialize", "Initializing Cxp Server Channel");
channelHandler = CreateChannelHandler();
if (channelHandler == null)
{
Log?.Information(className, "Initialize", "Failed to Initialize Cxp Server Channel");
return(false);
}
bootstrap = new Bootstrap();
group = new MultithreadEventLoopGroup();
encoder = new StringEncoder();
decoder = new StringDecoder();
bootstrap
.Group(group)
.Channel <TcpSocketChannel>()
.Option(ChannelOption.TcpNodelay, true)
.Handler(channelHandler);
Log?.Information(className, "Initialize", "Cxp Server Channel Initialized");
return(true);
}
public void Encode_ABC_to_BCD_with_key_1()
{
// Принцип ААА
// A - Arrange - ввод
// A - Act - 1 действие
// A - Assert - проверка
#region Arrange
var str = "ABC";
var expected_result = "BCD";
var key = 1;
#endregion
#region Act
var actual_result = StringEncoder.Encode(str, key);
#endregion
#region Assert
Assert.AreEqual(expected_result, actual_result);
#endregion
}
public string DecodeString(string encodedString)
{
var encoder = new StringEncoder(this.EncodingFormat);
Debug.WriteLine($"Decoding {encodedString}");
return(encoder.DecodeString(encodedString));
}
public void Decode_BCD_to_ABC_with_key_1()
{
// Принцип ААА
// A - Arrange
// A - Act
// A - Assert
#region Arrange
var str = "BCD";
var expected_result = "ABC";
var key = 1;
#endregion
#region Act
var actual_result = StringEncoder.Decode(str, key);
#endregion
#region Assert
Assert.AreEqual(expected_result, actual_result);
#endregion
}
public static string ConvertToBase64(string original)
{
var bytes = Encoding.ASCII.GetBytes(original);
var base64String = StringEncoder.ConvertBytesToString(bytes, EncodingFormats.Base64);
return(base64String);
}
public static string ConvertFromBase64(string base64)
{
var bytes = StringEncoder.GetBytesFromString(base64, EncodingFormats.Base64);
var asciiString = StringEncoder.ConvertBytesToString(bytes, EncodingFormats.ASCII);
return(asciiString);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: static byte[] encode(String charsetName, char[] ca, int off, int len) throws java.io.UnsupportedEncodingException
internal static sbyte[] Encode(String charsetName, char[] ca, int off, int len)
{
StringEncoder se = Deref(Encoder);
String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;
if ((se == null) || !(csn.Equals(se.RequestedCharsetName()) || csn.Equals(se.CharsetName())))
{
se = null;
try
{
Charset cs = LookupCharset(csn);
if (cs != null)
{
se = new StringEncoder(cs, csn);
}
}
catch (IllegalCharsetNameException)
{
}
if (se == null)
{
throw new UnsupportedEncodingException(csn);
}
Set(Encoder, se);
}
return(se.Encode(ca, off, len));
}
public void Receive_one_message()
{
var slice1 = new BufferSlice(new byte[65535], 0, 65535);
var encoder1 = new StringEncoder();
var decoder1 = new StringDecoder();
var expected = "Hello".PadRight(5000);
var outBuffer = new byte[expected.Length + 4];
BitConverter2.GetBytes(expected.Length, outBuffer, 0);
Encoding.UTF8.GetBytes(expected, 0, expected.Length, outBuffer, 4);
object actual = null;
var evt = new ManualResetEvent(false);
var stream = new SslStream(new NetworkStream(_helper.Server));
stream.BeginAuthenticateAsServer(_certificate, OnAuthenticated, stream);
var sut1 = CreateClientChannel(slice1, encoder1, decoder1);
sut1.MessageReceived = (channel, message) =>
{
actual = message;
evt.Set();
};
sut1.Assign(_helper.Client);
evt.WaitOne(500); // wait on authentication
evt.Reset();
stream.Write(outBuffer);
evt.WaitOne(500).Should().BeTrue();
actual.Should().Be(expected);
}
private void EncodeAll(String[] strings, String expectedEncoding)
{
foreach (String str in strings)
{
Assert.AreEqual(expectedEncoding, StringEncoder.Encode(str), "Problem with " + str);
}
}
public void Constructors()
{
// Test fixed length properties.
StringMessageHeaderFormatter formatter = new StringMessageHeaderFormatter(
new FixedLengthManager(12), StringEncoder.GetInstance(),
SpacePaddingRight.GetInstance(false));
Assert.IsTrue(formatter.LengthManager.MaximumLength == 12);
Assert.IsTrue(formatter.Encoder == StringEncoder.GetInstance());
Assert.IsTrue(formatter.Padding == SpacePaddingRight.GetInstance(false));
// Test variable length properties without padding.
formatter = new StringMessageHeaderFormatter(new VariableLengthManager(1, 800,
StringLengthEncoder.GetInstance(5)), StringEncoder.GetInstance());
Assert.IsTrue(formatter.LengthManager.MaximumLength == 800);
Assert.IsTrue(formatter.Encoder == StringEncoder.GetInstance());
Assert.IsTrue(formatter.Padding == null);
// Test variable length properties with padding.
formatter = new StringMessageHeaderFormatter(new VariableLengthManager(1,
999, StringLengthEncoder.GetInstance(3)), StringEncoder.GetInstance(),
SpacePaddingRight.GetInstance(false));
Assert.IsTrue(formatter.LengthManager.MaximumLength == 999);
Assert.IsTrue(formatter.Encoder == StringEncoder.GetInstance());
Assert.IsTrue(formatter.Padding == SpacePaddingRight.GetInstance(false));
}
public string EncodeString(string plainString, Certificate cert)
{
var encoder = new StringEncoder(this.EncodingFormat);
Debug.WriteLine($"Encoding {plainString}");
return(GetFormatCode(this.EncodingFormat) + ":" + encoder.EncodeString(plainString));
}
public void SetUp()
{
_encoder = StringEncoder.GetInstance();
Assert.IsNotNull(_encoder);
_data = "Sample data";
_binaryData = Encoding.UTF7.GetBytes(_data);
}
/// <summary>
/// Send string data to the server
/// </summary>
/// <param name="data"></param>
public void Send(string data)
{
if (string.IsNullOrEmpty(data))
{
return;
}
Send(StringEncoder.GetBytes(data));
}
public void Write(TcpClient client, string data)
{
if (data == null)
{
return;
}
Write(client, StringEncoder.GetBytes(data));
}
public void Broadcast(string data, TcpClient client)
{
if (data == null)
{
return;
}
Broadcast(StringEncoder.GetBytes(data), client);
}
public void Write(string data)
{
if (data == null)
{
return;
}
Write(StringEncoder.GetBytes(data));
}
public void Broadcast(string data)
{
if (data == null)
{
return;
}
Broadcast(StringEncoder.GetBytes(data));
}
public void Instantiation()
{
FieldFormatterEventArgs eventArgs = new FieldFormatterEventArgs(
new StringFieldFormatter(11, new FixedLengthManager(6), StringEncoder.GetInstance()));
Assert.IsNotNull(eventArgs.FieldFormatter);
Assert.IsTrue(eventArgs.FieldFormatter.FieldNumber == 11);
}
//
//Transform string to server message --------- This is the method to call
// |
public void SendDataToClient(string data, TcpClient client) //
{ //
if (data == null)
{
return;
} //
SendDATA(StringEncoder.GetBytes(data), client); //
} //
public void Pointers_To_Other_Words_Inside_Vocab_Data_Should_Be_Updated_When_Sorting()
{
const string SCode = @"
.NEW 6
; 64 bytes for header
.WORD 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.WORD 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.VOCBEG 8,6
W?ZEBRA::
.ZWORD ""zebra""
.WORD W?HORSE
W?HORSE::
.ZWORD ""horse""
.WORD W?DONKEY
W?DONKEY::
.ZWORD ""donkey""
.WORD W?ZEBRA
W?MULE::
.ZWORD ""mule""
.WORD W?MULE
.VOCEND
.END";
Assert.IsTrue(TestHelper.Assemble(SCode, out var mstr));
var buffer = mstr.GetBuffer();
/* After sorting:
* donkey firstEntry + entryLength*0 64 70
* horse firstEntry + entryLength*1 72 78
* mule firstEntry + entryLength*2 80 86
* zebra firstEntry + entryLength*3 88 94
*/
const int firstEntryAddr = 64;
const int entryLength = 8;
const int zwordLength = 6;
ushort donkeyAddr = firstEntryAddr + entryLength * 0;
ushort horseAddr = firstEntryAddr + entryLength * 1;
ushort muleAddr = firstEntryAddr + entryLength * 2;
ushort zebraAddr = firstEntryAddr + entryLength * 3;
var encoder = new StringEncoder();
AssertZword(buffer, encoder, zwordLength, donkeyAddr, "donkey");
AssertZword(buffer, encoder, zwordLength, horseAddr, "horse");
AssertZword(buffer, encoder, zwordLength, muleAddr, "mule");
AssertZword(buffer, encoder, zwordLength, zebraAddr, "zebra");
AssertWord(buffer, donkeyAddr + zwordLength, zebraAddr);
AssertWord(buffer, horseAddr + zwordLength, donkeyAddr);
AssertWord(buffer, muleAddr + zwordLength, muleAddr);
AssertWord(buffer, zebraAddr + zwordLength, horseAddr);
}
public void Decode_BCD_to_ABC_with_key_1()
{
var str = "BCD";
var expected_result = "ABC";
var key = 1;
var actual_result = StringEncoder.Decode(str, key);
Assert.AreEqual(expected_result, actual_result);
}
public virtual void AddAttribute(string key, string value = null, StringEncoder encoder = null)
{
if (String.IsNullOrWhiteSpace(key))
{
throw new ArgumentException(ExceptionMessages.NotNullOrWhitespace("key"));
}
Attributes[key] = (encoder == null ? DefaultAttributeEncoder : encoder).Encode(value);
}
public void ShouldEncodeEmptyStringsWithoutHuffmanEncoding()
{
var testStr = "";
var bytes = StringEncoder.Encode(testStr, HuffmanStrategy.Never);
Assert.Equal(1, bytes.Length);
// Compare the bytes
Assert.Equal(0x00, bytes[0]);
}
public void EncodeTest()
{
const string str = "asd";
const int key = 1;
const string expected_str = "bte";
var actual_str = StringEncoder.Encode(str, key);
Assert.AreEqual(expected_str, actual_str);
}
public void Encode_WhenNoValueIsPassed_ShouldReturnEmptyString()
{
//Arrange
var sut = new StringEncoder();
//Act
var result = sut.Encode("");
//Assert
result.Should().BeNullOrEmpty();
}
public void Write(string data)
{
if (data == null)
{
return;
}
var byteData = StringEncoder.GetBytes(data).ToList();
byteData.Add(Delimiter);
Write(byteData.ToArray());
}
public static void Main(string[] args)
{
try
{
using (var server = new NetServer())
{
server.Listen((self) =>
{
System.Console.WriteLine("Server is listening on: " + self.Address.ToString());
});
server.Connect((channel) =>
{
System.Console.WriteLine("Client connected.");
channel.Fault((c, exception) =>
{
System.Console.WriteLine(((MiniNet.Exceptions.SocketException)exception).StatusCode.ToString());
System.Console.WriteLine(exception.ToString());
});
var encoding = Encoding.Unicode;
var decoder = new StringDecoder(encoding);
var encoder = new StringEncoder(encoding);
//channel.Authenticate();
channel.Start();
channel.Message((self, buffer) =>
{
if (buffer.Size > 0)
{
var str = decoder.Process(buffer);
System.Console.WriteLine(str + "-" + buffer.Size + "-");
System.Console.WriteLine(buffer.DumpHex(int.MaxValue));
}
});
/*var payload = "Server: Hello Client";
var message = MiniNet.Buffers.Buffer.Create(encoding.GetByteCount(payload));
encoder.Process(message, payload);
channel.SendAsync(message);*/
Thread.Sleep(1000);
//channel.Close();
});
server.Fault((exception) =>
{
System.Console.WriteLine(exception.ToString());
});
server.Bind(8080, "localhost");
using (var client = new TcpClient())
{
client.NoDelay = true;
client.Connect(server.Address.Host, server.Address.Port);
Thread.Sleep(100);
var encoding = new UnicodeEncoding(false, false, true);
var stream = client.GetStream();
//var reader = new StreamReader(stream, encoding);
var writer = new StreamWriter(stream, encoding) { AutoFlush = true };
for (int i=1; i<=4; i++)
{
/*var bytesReceived = new byte[1024];
var lengthReceived = client.GetStream().Read(bytesReceived, 0, bytesReceived.Length);
if (lengthReceived > 0)
{
var message = encoding.GetString(bytesReceived, 0, lengthReceived);
System.Console.WriteLine(MiniNet.Buffers.Buffer.DumpHex(bytesReceived, 0, lengthReceived, int.MaxValue));
System.Console.WriteLine("'" + message + "'" + lengthReceived);
}*/
writer.Write("Client: Hello Server");
}
Thread.Sleep(100);
System.Console.WriteLine("Press ENTER to quit");
System.Console.ReadLine();
client.Close();
}
}
}
catch (Exception ex)
{
System.Console.WriteLine(ex.ToString());
System.Console.WriteLine(ex.StackTrace);
}
}
