public void EndWithJsonPadding()
{
this.settings.JsonPCallback = "foo";
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
target.End();
this.StreamAsString(target).Should().Be(")");
}
public void EndDoesNothingNormally()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
target.End();
Assert.Empty(this.StreamAsString(target));
}
public void StartDoesNothingNormally()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
target.Start();
this.StreamAsString(target).Should().BeEmpty();
}
public void WriteRawValueWritesRawString()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
const string value = "string value";
target.WriteRawValue(value);
this.StreamAsString(target).Should().Be(value);
}
public void writeRawValue <T>(List <T> values, RawValueWriter <T> writer, int stride)
{
beginRawArray();
if (values != null)
{
if (stride <= 1)
{
foreach (var cur in values)
{
writeValue <T>(cur, writer);
}
}
else
{
int index = 0;
foreach (var cur in values)
{
writeValue <T>(cur, writer, index == 0);
index++;
if (index >= stride)
{
index = 0;
}
}
}
}
endArray();
}
public void WriteRawValueWritesGeographyValue()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
var value = GeographyPoint.Create(22.2, 22.2);
target.WriteRawValue(value);
this.StreamAsString(target).Should().Be("SRID=4326;POINT (22.2 22.2)");
}
public void WriteRawValueWritesGeometryValue()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
var value2 = GeometryPoint.Create(1.2, 3.16);
target.WriteRawValue(value2);
this.StreamAsString(target).Should().Be("SRID=0;POINT (1.2 3.16)");
}
public void WriteRawValueWritesDate()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
Date value = new Date(2014, 9, 18);
target.WriteRawValue(value);
this.StreamAsString(target).Should().Be("2014-09-18");
}
public void WriteRawValueWritesTimeOfDay()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
TimeOfDay value = new TimeOfDay(9, 47, 5, 900);
target.WriteRawValue(value);
this.StreamAsString(target).Should().Be("09:47:05.9000000");
}
public void WriteRawValueWritesGeographyValue()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
var value = GeographyPoint.Create(22.2, 22.2);
target.WriteRawValue(value);
this.StreamAsString(target).Should().Be(@"{""type"":""Point"",""coordinates"":[22.2,22.2],""crs"":{""type"":""name"",""properties"":{""name"":""EPSG:4326""}}}");
}
public void StartWithJsonPadding()
{
this.settings.JsonPCallback = "foo";
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
target.Start();
Assert.Equal("foo(", this.StreamAsString(target));
}
public void WriteRawValueWritesGeometryValue()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
var value = GeometryPoint.Create(1.2, 3.16);
target.WriteRawValue(value);
Assert.Equal(@"{""type"":""Point"",""coordinates"":[1.2,3.16],""crs"":{""type"":""name"",""properties"":{""name"":""EPSG:0""}}}", this.StreamAsString(target));
}
private string StreamAsString(RawValueWriter target)
{
if (target.TextWriter != null)
{
target.TextWriter.Flush();
}
this.stream.Flush();
this.stream.Position = 0;
return new StreamReader(this.stream).ReadToEnd();
}
TryWriteWithoutResponseAsync_ForCharacteristicDoesNotSupportWrite_DoesNotCallTryWriteValueAsync(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.None);
await sut.TryWriteValueAsync(characteristic,
buffer);
await characteristic.DidNotReceive( )
.WriteValueAsync(buffer);
}
private async Task <string> SetupRawValueWriterAndRunTestAsync(Func <RawValueWriter, Task> func)
{
var rawValueWriter = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
await func(rawValueWriter);
await rawValueWriter.FlushAsync();
await this.stream.FlushAsync();
this.stream.Position = 0;
return(await new StreamReader(this.stream).ReadToEndAsync());
}
public void TryWriteWithoutResponseAsync_ForCharacteristicIsNull_Throws(
RawValueWriter sut,
IBuffer buffer)
{
Func <Task> action = async( ) =>
{
await sut.TryWriteWithoutResponseAsync(null !,
buffer);
};
action.Should( )
.Throw <ArgumentNullException> ( )
.WithParameter("characteristic");
}
public async Task TryWritableAuxiliariesValueAsync_ForGattCommunicationStatusIsProtocolError_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.WritableAuxiliaries)
.WithWriteValueAsyncResult(GattCommunicationStatus.ProtocolError);
var actual = await sut.TryWritableAuxiliariesValueAsync(characteristic,
buffer);
actual.Should( )
.BeFalse( );
}
public async Task TryWriteValueAsync_ForGattCommunicationStatusIsAccessDenied_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.Write)
.WithWriteValueAsyncResult(GattCommunicationStatus.AccessDenied);
var actual = await sut.TryWriteValueAsync(characteristic,
buffer);
actual.Should( )
.BeFalse( );
}
public void TryWriteValueAsync_ForBufferIsNull_Throws(
RawValueWriter sut,
IGattCharacteristicWrapper characteristic)
{
Func <Task> action = async( ) =>
{
await sut.TryWriteValueAsync(characteristic,
null !);
};
action.Should( )
.Throw <ArgumentNullException> ( )
.WithParameter("buffer");
}
public async Task TryWritableAuxiliariesValueAsync_ForCharacteristicDoesNotSupportWrite_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.None)
.WithWriteValueAsyncResult(GattCommunicationStatus.AccessDenied);
var actual = await sut.TryWritableAuxiliariesValueAsync(characteristic,
buffer);
actual.Should( )
.BeFalse( );
}
public async Task TryWriteWithoutResponseAsync_ForGattCommunicationStatusIsAccessDenied_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer,
IGattWriteResultWrapper result)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.WriteWithoutResponse)
.WithWriteValueWithResultAsync(result);
var actual = await sut.TryWriteWithoutResponseAsync(characteristic,
buffer);
actual.Should( )
.Be(result);
}
TryWriteWithoutResponseAsync_ForCharacteristicDoesNotWriteWithoutResponse_GattWriteResultNotSupported(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer,
IGattWriteResultWrapper result)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.None)
.WithWriteValueWithResultAsync(result);
var actual = await sut.TryWriteWithoutResponseAsync(characteristic,
buffer);
actual.Should( )
.Be(GattWriteResultWrapper.NotSupported);
}
public async Task TryWriteRawValue_ForKnownCharacteristics_WritesRawValuesAsync( )
{
var sut = CreateSut( );
ServiceWrapper.Uuid
.Returns(sut.GattServiceUuid);
await sut.Initialize <Control> ( )
.Refresh( );
await sut.TryWriteRawControl2(RawValue1);
await RawValueWriter.Received( )
.TryWriteValueAsync(CharacteristicWrapper1,
Arg.Is <IBuffer> (x => x.Length == RawValue1.Length));
}
public async Task TryWriteRawValue_ForKnownCharacteristicsAndFailedToWrite_ReturnsFalse( )
{
var sut = CreateSut( );
ServiceWrapper.Uuid
.Returns(sut.GattServiceUuid);
RawValueWriter.TryWriteValueAsync(Arg.Any <IGattCharacteristicWrapper> ( ),
Arg.Any <IBuffer> ( ))
.Returns(Task.FromResult(false));
await sut.Initialize <TestCharacteristicBase> ( )
.Refresh( );
sut.TryWriteRawValue(RawValue1)
.Result
.Should( )
.Be(false);
}
private async Task <bool> DoTryWriteValueAsync(string key,
IEnumerable <byte> bytes)
{
if (!Characteristics.Characteristics.TryGetValue(key,
out var characteristic))
{
Logger.Error($"Unknown characteristic with key '{key}'");
return(false);
}
if (characteristic != null)
{
return(await RawValueWriter.TryWriteValueAsync(characteristic,
bytes.ToArray( )
.AsBuffer( )));
}
Logger.Error($"Characteristic for key '{key}' is null");
return(false);
}
public void writeRawValue <T>(T[] values, RawValueWriter <T> writer)
{
writeRawValue(values, writer, 1);
}
public void writeValue <T>(T val, RawValueWriter <T> writerFunc, bool indent)
{
processComma(indent);
writerFunc(val);
}
public void writeKeyVal <T>(string key, T val, RawValueWriter <T> writerFunc)
{
writeKey(key);
writerFunc(val);
}
public void writeKeyVal <T>(string key, T[] val, RawValueWriter <T> writerFunc)
{
writeKeyVal(key, val, writerFunc, 1);
}
public void writeKeyVal <T>(string key, List <T> val, RawValueWriter <T> writerFunc, int stride)
{
writeKey(key);
writeRawValue(val, writerFunc, stride);
}
public void EndDoesNothingNormally()
{
RawValueWriter target = new RawValueWriter(this.settings, this.stream, new UTF32Encoding());
target.End();
this.StreamAsString(target).Should().BeEmpty();
}
