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