public void Should_compare_with_null_instance(double value)
{
var instance = new Hertz(value);
Assert.IsFalse(instance.Equals(null), "Equals");
Assert.AreEqual(1, instance.CompareTo(null), "CompareTo");
}
// Creates a new instance of NetworkServerConfiguration by reading values from environment variables
public static NetworkServerConfiguration CreateFromEnvironmentVariables()
{
var config = new NetworkServerConfiguration();
// Create case insensitive dictionary from environment variables
var envVars = new CaseInsensitiveEnvironmentVariables(Environment.GetEnvironmentVariables());
config.RunningAsIoTEdgeModule = !string.IsNullOrEmpty(envVars.GetEnvVar("IOTEDGE_APIVERSION", string.Empty));
config.IoTHubHostName = envVars.GetEnvVar("IOTEDGE_IOTHUBHOSTNAME", string.Empty);
config.GatewayHostName = envVars.GetEnvVar("IOTEDGE_GATEWAYHOSTNAME", string.Empty);
config.EnableGateway = envVars.GetEnvVar("ENABLE_GATEWAY", config.EnableGateway);
config.GatewayID = envVars.GetEnvVar("IOTEDGE_DEVICEID", string.Empty);
config.HttpsProxy = envVars.GetEnvVar("HTTPS_PROXY", string.Empty);
config.Rx2DataRate = envVars.GetEnvVar("RX2_DATR", -1) is var datrNum && (DataRateIndex)datrNum is var datr && Enum.IsDefined(datr) ? datr : null;
config.Rx2Frequency = envVars.GetEnvVar("RX2_FREQ") is { } someFreq?Hertz.Mega(someFreq) : null;
config.IoTEdgeTimeout = envVars.GetEnvVar("IOTEDGE_TIMEOUT", config.IoTEdgeTimeout);
// facadeurl is allowed to be null as the value is coming from the twin in production.
var facadeUrl = envVars.GetEnvVar("FACADE_SERVER_URL", string.Empty);
config.FacadeServerUrl = string.IsNullOrEmpty(facadeUrl) ? null : new Uri(envVars.GetEnvVar("FACADE_SERVER_URL", string.Empty));
config.FacadeAuthCode = envVars.GetEnvVar("FACADE_AUTH_CODE", string.Empty);
config.LogLevel = envVars.GetEnvVar("LOG_LEVEL", config.LogLevel);
config.LogToConsole = envVars.GetEnvVar("LOG_TO_CONSOLE", config.LogToConsole);
config.LogToTcp = envVars.GetEnvVar("LOG_TO_TCP", config.LogToTcp);
config.LogToHub = envVars.GetEnvVar("LOG_TO_HUB", config.LogToHub);
config.LogToTcpAddress = envVars.GetEnvVar("LOG_TO_TCP_ADDRESS", string.Empty);
config.LogToTcpPort = envVars.GetEnvVar("LOG_TO_TCP_PORT", config.LogToTcpPort);
config.NetId = new NetId(envVars.GetEnvVar("NETID", config.NetId.NetworkId));
config.AllowedDevAddresses = envVars.GetEnvVar("AllowedDevAddresses", string.Empty)
.Split(";")
.Select(s => DevAddr.TryParse(s, out var devAddr) ? (true, Value: devAddr) : default)
public void Should_not_throw_exception_on_division_by_zero(double value, double expectedValue)
{
var instance = new Hertz(value);
var actual = instance / 0d;
Assert.AreEqual(expectedValue, actual.Value);
}
public void TestDownstreamFrequency(Region region, Hertz inputFrequency, DataRateIndex inputDataRate, Hertz outputFreq, int?joinChannel = null)
{
var deviceJoinInfo = new DeviceJoinInfo(joinChannel);
Assert.True(region.TryGetDownstreamChannelFrequency(inputFrequency, inputDataRate, deviceJoinInfo, out var frequency));
Assert.Equal(frequency, outputFreq);
}
public void Should_initialize_instance(double value)
{
var actual = new Hertz(value);
Assert.IsAssignableFrom <Hertz>(actual);
Assert.AreEqual(value, actual.Value, nameof(actual.Value));
}
public void TestDownstreamRX2Frequency(Region region, Hertz?nwksrvrx2freq, Hertz expectedFreq, int?reportedJoinChannel = null, int?desiredJoinChannel = null)
{
var deviceJoinInfo = new DeviceJoinInfo(reportedJoinChannel, desiredJoinChannel);
var freq = region.GetDownstreamRX2Freq(nwksrvrx2freq, deviceJoinInfo, NullLogger.Instance);
Assert.Equal(expectedFreq, freq);
}
public void Should_compare_with_another_type_of_instance(double value)
{
var instance1 = new Hertz(value);
object instance2 = value;
Assert.IsFalse(instance1.Equals(instance2), "Equals");
Assert.Throws <ArgumentException>(() => instance1.CompareTo(instance2), "CompareTo");
}
public void Should_cast_from_double(double value)
{
var expected = new Hertz(value);
var actual = (Hertz)value;
Assert.AreEqual(expected, actual);
}
public void Should_cast_to_double(double value)
{
var instance = new Hertz(value);
var actual = (double)instance;
Assert.AreEqual(value, actual);
}
public void Should_divide_instance_by_double(double leftValue, double rightValue, double expectedValue)
{
var expected = new Hertz(expectedValue);
var instance = new Hertz(leftValue);
var actual = instance / rightValue;
Assert.AreEqual(expected, actual);
}
public void Should_absolute_value(double value, double expectedValue)
{
var expected = new Hertz(expectedValue);
var instance = new Hertz(value);
var actual = instance.Abs();
Assert.AreEqual(expected, actual);
}
public void Should_own_a_HashCode(double value)
{
var expected = value.GetHashCode();
var instance = new Hertz(value);
var actual = instance.GetHashCode();
Assert.AreEqual(expected, actual);
}
public void Should_format_string(string format, string mask)
{
var expected = string.Format(Consts.CultureEnUS, mask, 1.757899e2);
var instance = new Hertz(1.757899e2);
var actual = instance.ToString(format, Consts.CultureEnUS);
Assert.AreEqual(expected, actual);
}
public void Should_round_value_withDigit(double value, double expectedValue)
{
var expected = new Hertz(expectedValue);
var instance = new Hertz(value);
var actual = instance.Round(1);
Assert.AreEqual(expected, actual);
}
public void Should_roundvalue_withMode(MidpointRounding mode, double value, double expectedValue)
{
var expected = new Hertz(expectedValue);
var instance = new Hertz(value);
var actual = instance.Round(mode);
Assert.AreEqual(expected, actual);
}
public void TestRegionLimit(Region region, Hertz inputFrequency, DataRateIndex datarate, int?joinChannel = null)
{
var deviceJoinInfo = new DeviceJoinInfo(joinChannel);
var ex = Assert.Throws <LoRaProcessingException>(() => region.TryGetDownstreamChannelFrequency(inputFrequency, datarate, deviceJoinInfo, out _));
Assert.Equal(LoRaProcessingErrorCode.InvalidFrequency, ex.ErrorCode);
ex = Assert.Throws <LoRaProcessingException>(() => region.GetDownstreamDataRate(datarate));
Assert.Equal(LoRaProcessingErrorCode.InvalidDataRate, ex.ErrorCode);
}
public void Should_floor_value(double value, double expectedValue)
{
var expected = new Hertz(expectedValue);
var instance = new Hertz(value);
var actual = instance.Floor();
Assert.AreEqual(expected, actual);
}
public void Should_convert_to_string(double value)
{
var expected = $"{value:e} Hz";
var instance = new Hertz(value);
var actual = instance.ToString();
Assert.AreEqual(expected, actual);
}
public void Should_multiply_double_by_instance(double leftValue, double rightValue, double expectedValue)
{
var expected = new Hertz(expectedValue);
var instance = new Hertz(rightValue);
var actual = leftValue * instance;
Assert.AreEqual(expected, actual);
}
public void Should_subtract_two_instances(double leftValue, double rightValue, double expectedValue)
{
var expected = new Hertz(expectedValue);
var leftInstance = new Hertz(leftValue);
var rightInstance = new Hertz(rightValue);
var actual = leftInstance - rightInstance;
Assert.AreEqual(expected, actual);
}
public static RadioMetadata GenerateTestRadioMetadata(
DataRateIndex dataRate = DataRateIndex.DR2,
Hertz?frequency = null,
uint antennaPreference = 1,
ulong xtime = 100000,
uint gpstime = 100000,
double rssi = 2.0,
float snr = 0.1f) =>
new RadioMetadata(dataRate, frequency ?? Hertz.Mega(868.3),
new RadioMetadataUpInfo(antennaPreference, xtime, gpstime, rssi, snr));
public void Should_cast_from_Centihertz(double centihertzValue, double expectedValue)
{
var centihertzInstance = new SystemOfUnits.Frequency.Hertz.Centihertz(centihertzValue);
Hertz actual = centihertzInstance;
Assert.IsAssignableFrom <Hertz>(actual);
var actualValue = actual.Value;
Assert.AreEqual(expectedValue.ToString("E"), actualValue.ToString("E"));
}
public void FrequencyUnits()
{
RPM rpm = (RPM)7200;
Hertz frequency = (Hertz)rpm;
Radian_Sec angularvelocity = (Radian_Sec)frequency;
rpm = (RPM)angularvelocity;
Assert.AreEqual((Hertz)120.0, frequency, "RPM-to-Hetrz conversion failed");
Assert.AreEqual((Radian_Sec)(240.0 * Math.PI), angularvelocity, "Hertz-to-Radian_Sec conversion failed");
Assert.AreEqual((RPM)7200.0, rpm, "Radian_Sec-to-RPM conversion failed");
Second duration = (Second)1.0;
Cycles revolutions = frequency * duration;
Assert.AreEqual((Cycles)120.0, revolutions, "revolutions = frequency * duration conversion failed");
}
public void Should_compare_with_smaller_value(double baseValue, double smallerValue)
{
var baseInstance = new Hertz(baseValue);
var smallerInstance = new Hertz(smallerValue);
Assert.IsFalse(baseInstance.Equals(smallerInstance), "Equals");
Assert.IsFalse(baseInstance.Equals((object)smallerInstance), "Equals object");
Assert.IsFalse(baseInstance == smallerInstance, "==");
Assert.IsTrue(baseInstance != smallerInstance, "!=");
Assert.AreEqual(+1, baseInstance.CompareTo(smallerInstance), "CompareTo");
Assert.AreEqual(+1, baseInstance.CompareTo((object)smallerInstance), "CompareTo object");
Assert.IsFalse(baseInstance < smallerInstance, "<");
Assert.IsTrue(baseInstance > smallerInstance, ">");
Assert.IsFalse(baseInstance <= smallerInstance, "<=");
Assert.IsTrue(baseInstance >= smallerInstance, ">=");
}
public void Should_compare_with_same_value(double value)
{
var baseInstance = new Hertz(value);
var otherInstance = new Hertz(value);
Assert.IsTrue(baseInstance.Equals(otherInstance), "Equals");
Assert.IsTrue(baseInstance.Equals((object)otherInstance), "Equals object");
Assert.IsTrue(baseInstance == otherInstance, "==");
Assert.IsFalse(baseInstance != otherInstance, "!=");
Assert.AreEqual(0, baseInstance.CompareTo(otherInstance), "CompareTo");
Assert.AreEqual(0, baseInstance.CompareTo((object)otherInstance), "CompareTo object");
Assert.IsFalse(baseInstance < otherInstance, "<");
Assert.IsFalse(baseInstance > otherInstance, ">");
Assert.IsTrue(baseInstance <= otherInstance, "<=");
Assert.IsTrue(baseInstance >= otherInstance, ">=");
}
public void Should_compare_with_bigger_value(double baseValue, double biggerValue)
{
var baseInstance = new Hertz(baseValue);
var biggerInstance = new Hertz(biggerValue);
Assert.IsFalse(baseInstance.Equals(biggerInstance), "Equals");
Assert.IsFalse(baseInstance.Equals((object)biggerInstance), "Equals object");
Assert.IsFalse(baseInstance == biggerInstance, "==");
Assert.IsTrue(baseInstance != biggerInstance, "!=");
Assert.AreEqual(-1, baseInstance.CompareTo(biggerInstance), "CompareTo");
Assert.AreEqual(-1, baseInstance.CompareTo((object)biggerInstance), "CompareTo object");
Assert.IsTrue(baseInstance < biggerInstance, "<");
Assert.IsFalse(baseInstance > biggerInstance, ">");
Assert.IsTrue(baseInstance <= biggerInstance, "<=");
Assert.IsFalse(baseInstance >= biggerInstance, ">=");
}
public void Should_have_a_symbol(double value)
{
IUnit actual = new Hertz(value);
Assert.AreEqual(Hertz.Symbol, actual.Symbol);
}
public void TestTryGetJoinChannelIndex(Region region, Hertz freq, int expectedIndex)
{
Assert.Equal(expectedIndex != -1, region.TryGetJoinChannelIndex(freq, out var channelIndex));
Assert.Equal(expectedIndex, channelIndex);
}
public RadioConfig(bool enable, Hertz freq)
{
Enable = enable;
Freq = freq;
}
public async Task When_Has_Custom_RX2DR_Should_Send_Correctly()
{
var devAddr = new DevAddr(0x023637F8);
var appSKey = TestKeys.CreateAppSessionKey(0xABC0200000000000, 0x09);
var nwkSKey = TestKeys.CreateNetworkSessionKey(0xABC0200000000000, 0x09);
var simDevice = new SimulatedDevice(TestDeviceInfo.CreateOTAADevice(1, deviceClassType: 'c', gatewayID: ServerGatewayID));
var devEUI = simDevice.DevEUI;
simDevice.SetupJoin(appSKey, nwkSKey, devAddr);
this.deviceApi.Setup(x => x.GetPrimaryKeyByEuiAsync(devEUI))
.ReturnsAsync("123");
var twin = simDevice.CreateOTAATwin(
desiredProperties: new Dictionary <string, object>
{
{ TwinProperty.RX2DataRate, "10" }
},
reportedProperties: new Dictionary <string, object>
{
{ TwinProperty.RX2DataRate, 10 },
{ TwinProperty.Region, LoRaRegionType.US915.ToString() },
// OTAA device, already joined
{ TwinProperty.DevAddr, devAddr.ToString() },
{ TwinProperty.AppSKey, appSKey.ToString() },
{ TwinProperty.NwkSKey, nwkSKey.ToString() },
{ TwinProperty.LastProcessingStationEui, new StationEui(ulong.MaxValue).ToString() }
});
this.deviceClient.Setup(x => x.GetTwinAsync(CancellationToken.None))
.ReturnsAsync(twin);
var c2dToDeviceMessage = new ReceivedLoRaCloudToDeviceMessage()
{
Payload = "hello",
DevEUI = devEUI,
Fport = TestPort,
MessageId = Guid.NewGuid().ToString(),
};
DownlinkMessage receivedDownlinkMessage = null;
this.downstreamMessageSender.Setup(x => x.SendDownstreamAsync(It.IsNotNull <DownlinkMessage>()))
.Returns(Task.CompletedTask)
.Callback <DownlinkMessage>(d => receivedDownlinkMessage = d);
var target = new DefaultClassCDevicesMessageSender(
this.serverConfiguration,
this.loRaDeviceRegistry,
this.downstreamMessageSender.Object,
this.frameCounterStrategyProvider,
NullLogger <DefaultClassCDevicesMessageSender> .Instance,
TestMeter.Instance);
Assert.True(await target.SendAsync(c2dToDeviceMessage));
this.downstreamMessageSender.Verify(x => x.SendDownstreamAsync(It.IsNotNull <DownlinkMessage>()), Times.Once());
EnsureDownlinkIsCorrect(receivedDownlinkMessage, simDevice, c2dToDeviceMessage);
Assert.Equal(DataRateIndex.DR10, receivedDownlinkMessage.Rx2.DataRate);
Assert.Equal(Hertz.Mega(923.3), receivedDownlinkMessage.Rx2.Frequency);
this.downstreamMessageSender.VerifyAll();
this.deviceApi.VerifyAll();
this.deviceClient.VerifyAll();
}
