public AggregatePower(string name, Power[] powers) { this.powers = powers; this.name = name; InitPower(); }
public void VerifyAllEnums() { var acceleration = new Acceleration(1, AccelerationUnit.BaseUnit); var angle = new Angle(1, AngleUnit.BaseUnit); var angularAcceleration = new AngularAcceleration(1, AngularAccelerationUnit.BaseUnit); var area = new Area(1, AreaUnit.BaseUnit); var density = new MassDensity(1, MassDensityUnit.BaseUnit); var electricCurrent = new ElectricCurrent(1, ElectricCurrentUnit.BaseUnit); var electricResistance = new ElectricResistance(1, ElectricResistanceUnit.BaseUnit); var electricVoltage = new ElectricPotential(1, ElectricPotentialUnit.BaseUnit); var energy = new Energy(1, EnergyUnit.BaseUnit); var force = new Force(1, ForceUnit.BaseUnit); var frequency = new Frequency(1, FrequencyUnit.BaseUnit); var jerk = new Jerk(1, JerkUnit.BaseUnit); var length = new Length(1, LengthUnit.BaseUnit); var mass = new Mass(1, MassUnit.BaseUnit); var massFlowRate = new MassFlowRate(1, MassFlowRateUnit.BaseUnit); var momentum = new Momentum(1, MomentumUnit.BaseUnit); var numeric = new Numeric(1, NumericUnit.BaseUnit); var power = new Power(1, PowerUnit.BaseUnit); var pressure = new Pressure(1, PressureUnit.BaseUnit); var speed = new Speed(1, SpeedUnit.BaseUnit); var temperature = new Temperature(1, TemperatureUnit.BaseUnit); var time = new Time(1, TimeUnit.BaseUnit); var torque = new Torque(1, TorqueUnit.BaseUnit); var volume = new Volume(1, VolumeUnit.BaseUnit); var volumetricFlowRate = new VolumetricFlowRate(1, VolumetricFlowRateUnit.BaseUnit); }
/// <summary> /// Construct the heading for a power. /// </summary> /// <param name="power"> /// The <see cref="Power"/> to consturct the /// </param> /// <returns> /// The header as a string encoded for HTML. /// </returns> /// <exception cref="ArgumentNullException"> /// No argument can be null. /// </exception> public string GetPowerHeading(Power power) { if (power == null) { throw new ArgumentNullException("power"); } StringBuilder result; List<string> additionalKeyWords; result = new StringBuilder(); result.AppendFormat(string.Format("{0} ", power.Name)); additionalKeyWords = new List<string>(); additionalKeyWords.Add(CharacterRendererHelper.GetActionType(power.Action)); if (power is AttackPower) { additionalKeyWords.Add("attack"); } else if (power.PowerSource != PowerSource.Item && power is UtilityPower) { additionalKeyWords.Add("utility"); } result.AppendFormat("({0})", string.Join("; ", additionalKeyWords.ToArray())); return result.ToString(); }
// Set the dot's power rather than rely on randomised, used for end of PlayField public void SetPower(Power newPower) { power = newPower; if (power == Power.CLEARALLCOLOUR) { texture.renderer.material.shader = Shader.Find ("Self-Illumin/Diffuse"); } }
public void Start(Power firmware) { var config = new RestApiConfiguration(); config.AddHandler("GET", "/boot/ping", "is server alive") .ReturnNothing() .HandledBy(() => {}); config.AddHandler("GET", "/boot/firmware", "get firmware info") .ReturnJson() .HandledBy(() => firmware.GetFirmwareInfoAsJson()); config.AddHandler("PUT", "/boot/firmware", "update firmware") .ReturnJson() .HandledWithStreamBy((s) => firmware.UpdateFirmware(s)); config.AddHandler("POST", "/boot/sysinfo", "get system state") .ReturnJson() .HandledBy(() => HardwareInfo.Instance.GetSystemInfo()); config.AddHandler("POST", "/boot/diskinfo", "list content of filesystem") .ReturnJson() .HandledBy(() => HardwareInfo.Instance.GetDiskInfo()); config.AddHandler("GET", "/boot/networks", "list network information") .ReturnJson() .HandledBy(() => HardwareInfo.Instance.GetNetworkInterfaceInfo()); config.AddHandler("GET", "/boot/log/full", "get full log") .ReturnJson() .HandledBy(() => Logger.Instance.Full.GetLinesAsJson()); config.AddHandler("GET", "/boot/log/errors", "get error log") .ReturnJson() .HandledBy(() => Logger.Instance.Errors.GetLinesAsJson()); config.AddHandler("POST", "/boot/ntp/sync", "sync time with NTP") .ReturnJson() .HandledBy(() => { RealTimeClock.Instance.UpdateFromNTP(); var status = new JsonObject(); status.Add("time", DateTime.Now); return status; }); config.AddHandler("POST", "/boot/reboot", "reboot the device") .SetNotes("This will reboot the device and not return") .ReturnNothing() .HandledBy(() => firmware.Reboot()); var credentials = CredentialValidatorFactory.CreateSimpleValidator("ChickenHouse", "admin", "hnsefyk"); var webService = new WebService(c_servicePort, credentials, config); string prefix = Name + ": "; webService.Logging.OnLogInfo += message => Logger.Instance.LogInfo(prefix + message); webService.Logging.OnLogError += message => Logger.Instance.LogError(prefix + message); webService.Logging.OnLogException += (message, ex) => Logger.Instance.LogException(prefix + message, ex); webService.Start(); }
static Shoot() { ShootAngles = new Angle[51, 600]; for (var p =5f; p < 10.01f; p += 0.1f) { for (var d = 200; d < 800; d++) { var d2 = d * d; var power = new Power(p); var speed = power.Speed; for (var t = 1; t < 1024; t++) { var ball = BallPath.GetDistance(speed, t); var player = PlayerPath.GetDistance(3, t, 40); if (ball.Squared + player.Squared > d2) { var angle = Angle.Atan((double)player / (double)ball); var spe = SpeedToKey(speed); var dis = DistanceToKey(d); ShootAngles[spe, dis] = angle; break; } } } } }
public DraculaCard(string abbreviation, Location location, Power power) { Abbreviation = abbreviation; Location = location; Power = power; IsRevealed = false; Color = ConsoleColor.DarkYellow; }
public DraculaCard(string abbreviation, Location location, Power power, ConsoleColor color) { Abbreviation = abbreviation; Location = location; Power = power; IsRevealed = false; Color = color; }
public void Shutdown(string comment, Power.ShutdownOptions options = Power.ShutdownOptions.Abort, string message = null, int seconds = 30) { var minutes = seconds/60.0; var timeDelay = (int) Math.Round(minutes); Power.QueueShutdown($"-h +{timeDelay} \"{comment}\"", options, message); }
void Start() { openingSpeed = openingLength / openingTime; leftClosedPos = left.localPosition; rightClosedPos = right.localPosition; power = GetComponent<Power>(); }
public void OpAddition() { var power1 = new Power(6000, PowerUnit.Watts); var power2 = new Power(1, PowerUnit.Kilowatts); var expected = new Power(7000, PowerUnit.Watts); (power1 + power2).ShouldEqual(expected); (power2 + power1).ShouldEqual(expected); }
public PowerCommand(MafiaGame game, VillageMember member, Power power) { this.game = game; this.member = member; this.power = power; this.name = power.Name; this.allowedInPublic = publicCommands.Contains(power.Name.ToLower()); }
public FactionCommand(MafiaGame game, VillageMember member, Power power) { this.game = game; this.member = member; this.power = power; this.name = power.Name; this.allowedInPublic = false; }
public void OpGreaterThanOrEqual() { var power1 = new Power(3000, PowerUnit.Watts); var power2 = new Power(3, PowerUnit.Kilowatts); var power3 = new Power(5000, PowerUnit.NewtonMetersPerSecond); (power1 >= power3).ShouldBeFalse(); (power3 >= power1).ShouldBeTrue(); (power1 >= power2).ShouldBeTrue(); (power2 >= power1).ShouldBeTrue(); }
public void OpInverseEquals() { var power1 = new Power(3000, PowerUnit.Watts); var power2 = new Power(3, PowerUnit.Kilowatts); var power3 = new Power(5000, PowerUnit.NewtonMetersPerSecond); (power1 != power2).ShouldBeFalse(); (power2 != power1).ShouldBeFalse(); (power1 != power3).ShouldBeTrue(); (power3 != power1).ShouldBeTrue(); }
public void OpDivision() { var power1 = new Power(2000, PowerUnit.Watts); var power2 = new Power(2, PowerUnit.Kilowatts); (power1 / power2).ShouldBeWithinEpsilonOf(1); (power2 / power1).ShouldBeWithinEpsilonOf(1); (power1 / 2).ShouldEqual(new Power(1000, PowerUnit.Watts)); (power2 / 2).ShouldEqual(new Power(1, PowerUnit.Kilowatts)); }
public void ToTarget_SomeWhere_XSqrt18YSqrt18() { var source = new Position(100, 100); var target = new Position(200, 200); var power = new Power(5); var act = Shoot.ToTarget(source, target, power); var exp = new Velocity(Math.Sqrt(18), Math.Sqrt(18)); CloudBallAssert.AreEqual(exp, act); }
private void SaveItem() { Power item = new Power(); item.Name = tbxName.Text.Trim(); item.GroupName = tbxGroupName.Text.Trim(); item.Title = tbxTitle.Text.Trim(); item.Remark = tbxRemark.Text.Trim(); DB.Powers.Add(item); DB.SaveChanges(); }
public EthicDefinition( int primaryHue, TextDefinition title, TextDefinition adjunct, TextDefinition joinPhrase, Power[] powers ) { m_PrimaryHue = primaryHue; m_Title = title; m_Adjunct = adjunct; m_JoinPhrase = joinPhrase; m_Powers = powers; }
void AddNewPowerToList(Power zPower) { GameObject entryobj = Instantiate(PowerEntryPrefab.gameObject) as GameObject; entryobj.transform.SetParent(PowerEntriesList); entryobj.transform.localScale = PowerEntryPrefab.transform.localScale; Powerentry entry = entryobj.GetComponent<Powerentry>(); entry.Assign(zPower); InstantiatedEntries.Add(entry); }
public void WithVelocity_SomeWhere_X100plusSqrt17Y100plusSqrt18() { var source = new Position(100, 100); var target = new Velocity(15, 15); var power = new Power(5); var act = Shoot.WithVelocity(source, target, power); var exp = new Velocity(100d + Math.Sqrt(18), 100d+ Math.Sqrt(18)); Assert.AreEqual(exp.X, act.X, 0.0001f); Assert.AreEqual(exp.Y, act.Y, 0.0001f); }
void Start() { power = GetPowerComponent (powerComponent); if (power == null) { Debug.LogError ("Meter [" + name + "] not tied to a power."); } // Cache the width of the fill meter. maxWidth = fill.GetComponent<GUITexture>().pixelInset.width; originalColor = fill.GetComponent<GUITexture>().color; }
public void Verify_Add_Should_AddTheEntityToTheContext() { // Arrange Mock<IDbSet<Power>> mockSetPowers; var mockContext = PowersMockingSetup.DoMockingSetupForContext(false, out mockSetPowers); var repository = new PowersRepository(mockContext.Object); var powers = new Power { Active = true, CustomKey = "SALVATORE-RAA", }; // Act repository.Add(powers); // Assert mockSetPowers.Verify(x => x.Add(powers), Times.Once); }
public Power TogglePower() { if (statusPower == Power.On) { POWER = Power.Off; } else { POWER = Power.On; } return POWER; }
/// <summary> /// 用户登录 /// </summary> /// <returns>0:用户密码正确,账号未被冻结,并且提取相应的权限值</returns> /// <returns>1:用户密码错误</returns> /// <returns>2:用户尚未注册</returns> /// <returns>3:账号被冻结</returns> public int Login() { SqlConnection sql = DataBaseOperations.CreateConnection(); string cmdText = "select * from Users where Name='" + Name + "'"; SqlDataReader sqlDataReader = DataBaseOperations.GetSqlDataReader(cmdText, sql); //如果查询到该用户,匹配用户名/密码 if (sqlDataReader.HasRows)//根据查询结果里面的行数判断是否有该用户 { sqlDataReader.Close();//关闭sqlDataReader,必要操作 SqlDataAdapter sqlDataAdapter = DataBaseOperations.GetSqlDataAdapter(cmdText, sql); DataSet dataSet = DataBaseOperations.GetDataSet(sqlDataAdapter); //对用户密码进行匹配 if (dataSet.Tables[0].Rows[0]["Password"].ToString() == Password) { string power = dataSet.Tables[0].Rows[0]["Power"].ToString();//获取数据库中用户权限(string) //将string权限转换为Power类型 switch (power) { case "Customer": Powers = Power.Customer; break; case "Manager": Powers = Power.Manager; break; } if (Convert.ToInt32(dataSet.Tables[0].Rows[0]["LegalityState"]) == 0) { sql.Close();//关闭sql连接 return 0; //用户密码正确,账号未被冻结,提示前台进行相应的操作 } else { sql.Close();//关闭sql连接 return 3;//账号被冻结,提示前台进行相应的操作 } } else { sql.Close();//关闭sql连接 return 1;//用户密码错误,提示前台进行相应的操作 } } sql.Close();//关闭sql连接 return 2;//用户名不存在,提示用户注册 }
public PossibleTrailSlot(Location location, Power power, TimeOfDay timeOfDay) { Location = location; Power = power; if (power == Power.Feed || power == Power.DarkCall) { IsRevealed = true; } else { IsRevealed = false; } TimeOfDay = timeOfDay; }
void GetRoomSwitchables() { Power[] doors = new Power[0]; if(transform.FindChild("Doors")) doors = transform.FindChild("Doors").GetComponentsInChildren<Power>(true); Power[] otherSwitchables = GetComponentsInChildren<Power>(true); roomSwitchables = new GameObject[doors.Length + otherSwitchables.Length]; for(byte counter = 0; counter < doors.Length; counter++) roomSwitchables[counter] = doors[counter].gameObject; for(byte counter = 0; counter < otherSwitchables.Length; counter++) roomSwitchables[doors.Length + counter] = otherSwitchables[counter].gameObject; }
//private bool bGivingCommands; public PolarBear(Vector2 position) : base(position) { power = Power.Normal; Scale = 1; IsAlive = true; mScale = new Vector2(Scale, Scale); MaxHitPoints = 5; CurHitPoints = 5; mInvincibleDelay = 500.0f; mInvincibleDeltaTime = 0; //bGivingCommands = false; }
public PossibleTrailSlot(Location location, Power power) { Location = location; Power = power; if (power == Power.Feed || power == Power.DarkCall) { IsRevealed = true; } else { IsRevealed = false; } TimeOfDay = TimeOfDay.None; CardBack = CardBack.None; }
/// <summary> /// Determines the winners in the tie. In the case of 2 players having the same cards but from a different suit they split the pot. /// </summary> /// <param name="winnersWithSameHand">All of the players that have a winning hand with the same power</param> /// <param name="strongestHandPower">The strongest hand that is owned by 1 player in the current game</param> /// <returns>All of the players that have the strongest hand and highest cards. Winners may be more than 1 if 2 or more have the same cards</returns> private static List<IPlayer> WinnersInTie(List<IPlayer> winnersWithSameHand, Power strongestHandPower) { var winnersInTie = new List<IPlayer>(); if (strongestHandPower == Power.StraightFlush || strongestHandPower == Power.Straigth) { ////In the case of King, Ace, 2, 3, 4 and 2, 3, 4, 5 ,6 The first hand wins even though the last card is weaker BreakTieUsingCardIndex(winnersWithSameHand, winnersInTie, 0); } else { BreakTieUsingCardIndex(winnersWithSameHand, winnersInTie, winnersWithSameHand[0].CurrentHand.Cards.Count - 1); } return winnersInTie; }
public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException() { var v = Power.FromWatts(1); Assert.Throws <ArgumentOutOfRangeException>(() => v.Equals(Power.FromWatts(1), -1, ComparisonType.Relative)); }
public void EqualsReturnsFalseOnTypeMismatch() { Power watt = Power.FromWatts(1); Assert.False(watt.Equals(new object())); }
public void PowerDividedByTorqueEqualsRotationalSpeed() { RotationalSpeed rotationalSpeed = Power.FromWatts(15.0) / Torque.FromNewtonMeters(3); Assert.Equal(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(5)); }
/// <summary> /// Initializes a new instance of the <see cref="Gu.Units.Wpf.PowerExtension"/> class. /// </summary> /// <param name="value"><see cref="Gu.Units.Power"/>.</param> public PowerExtension(Power value) { this.Value = value; }
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) { var quantity = Power.FromWatts(value); Assert.Equal(Power.FromWatts(-value), -quantity); }
public void Convert_ToDateTime_ThrowsInvalidCastException() { var quantity = Power.FromWatts(1.0); Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity)); }
public void PowerDividedBySpeedEqualsForce() { Force force = Power.FromWatts(15.0) / Speed.FromMetersPerSecond(3); Assert.Equal(force, Force.FromNewtons(5)); }
public void ToString_NullArgs_ThrowsArgumentNullException() { var quantity = Power.FromWatts(1.0); Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null)); }
public void Convert_ToDecimal_EqualsValueAsSameType() { var quantity = Power.FromWatts(1.0); Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity)); }
public void Convert_ToDouble_EqualsValueAsSameType() { var quantity = Power.FromWatts(1.0); Assert.Equal((double)quantity.Value, Convert.ToDouble(quantity)); }
public void Convert_ToInt16_EqualsValueAsSameType() { var quantity = Power.FromWatts(1.0); Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity)); }
private void Load(TextAsset levelFile) { if (playfieldContainer != null) { Destroy(playfieldContainer); } Button.gameObject.SetActive(false); var rows = levelFile.text.Split('\n'); int width = rows[0].Split(',').Length, height = rows.Length; playfieldContainer = Instantiate(new GameObject(string.Empty, typeof(RectTransform)), transform); playfieldContainer.GetComponent <RectTransform>().localPosition = new Vector3(-width, height) / 2 * block_size; playfieldContainer.name = "Playfield"; blocks = new Block[width, height]; for (var rowIndex = 0; rowIndex < height; rowIndex++) { var row = rows[rowIndex].Split(','); for (var j = 0; j < width; j++) { var block = Instantiate(BlockTypes[int.Parse(row[j])], playfieldContainer.transform); block.GetComponent <RectTransform>().localPosition = new Vector2(j, -rowIndex) * block_size; block.GetComponent <RectTransform>().Rotate(Vector3.back, 90 * Random.Range(0, 3)); block.name = "Block " + j + "-" + rowIndex; block.OnRotation = OnBlockRotation; blocks[j, rowIndex] = block; var power = block as Power; if (power != null) { powerBlock = power; } } } for (var i = 0; i < blocks.GetLength(0); i++) { for (var j = 0; j < blocks.GetLength(1); j++) { var block = blocks[i, j]; if (i > 0) { block.Left = blocks[i - 1, j]; } if (i < blocks.GetLength(0) - 1) { block.Right = blocks[i + 1, j]; } if (j > 0) { block.Up = blocks[i, j - 1]; } if (j < blocks.GetLength(1) - 1) { block.Down = blocks[i, j + 1]; } } } if (powerBlock.FindPath()) { Load(levelFile); } }
public void CompareToThrowsOnNull() { Power watt = Power.FromWatts(1); Assert.Throws <ArgumentNullException>(() => watt.CompareTo(null)); }
public void ToUnit_WithNullUnitSystem_ThrowsNullException() { var watt = Power.FromWatts(1); Assert.Throws <ArgumentNullException>(() => watt.ToUnit(null)); }
public void CompareToThrowsOnTypeMismatch() { Power watt = Power.FromWatts(1); Assert.Throws <ArgumentException>(() => watt.CompareTo(new object())); }
public void PowerDividedByMassFlowEqualsSpecificEnergy() { SpecificEnergy specificEnergy = Power.FromWatts(15.0) / MassFlow.FromKilogramsPerSecond(3); Assert.Equal(specificEnergy, SpecificEnergy.FromJoulesPerKilogram(5)); }
public void ToBaseUnit_ReturnsQuantityWithBaseUnit() { var quantityInBaseUnit = Power.FromWatts(1).ToBaseUnit(); Assert.Equal(Power.BaseUnit, quantityInBaseUnit.Unit); }
protected bool Equals(Cube other) { return(Power.Equals(other.Power) && Toughness.Equals(other.Toughness)); }
public void ToUnit() { var watt = Power.FromWatts(1); var boilerhorsepowerQuantity = watt.ToUnit(PowerUnit.BoilerHorsepower); AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, (double)boilerhorsepowerQuantity.Value, BoilerHorsepowerTolerance); Assert.Equal(PowerUnit.BoilerHorsepower, boilerhorsepowerQuantity.Unit); var britishthermalunitperhourQuantity = watt.ToUnit(PowerUnit.BritishThermalUnitPerHour); AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, (double)britishthermalunitperhourQuantity.Value, BritishThermalUnitsPerHourTolerance); Assert.Equal(PowerUnit.BritishThermalUnitPerHour, britishthermalunitperhourQuantity.Unit); var decawattQuantity = watt.ToUnit(PowerUnit.Decawatt); AssertEx.EqualTolerance(DecawattsInOneWatt, (double)decawattQuantity.Value, DecawattsTolerance); Assert.Equal(PowerUnit.Decawatt, decawattQuantity.Unit); var deciwattQuantity = watt.ToUnit(PowerUnit.Deciwatt); AssertEx.EqualTolerance(DeciwattsInOneWatt, (double)deciwattQuantity.Value, DeciwattsTolerance); Assert.Equal(PowerUnit.Deciwatt, deciwattQuantity.Unit); var electricalhorsepowerQuantity = watt.ToUnit(PowerUnit.ElectricalHorsepower); AssertEx.EqualTolerance(ElectricalHorsepowerInOneWatt, (double)electricalhorsepowerQuantity.Value, ElectricalHorsepowerTolerance); Assert.Equal(PowerUnit.ElectricalHorsepower, electricalhorsepowerQuantity.Unit); var femtowattQuantity = watt.ToUnit(PowerUnit.Femtowatt); AssertEx.EqualTolerance(FemtowattsInOneWatt, (double)femtowattQuantity.Value, FemtowattsTolerance); Assert.Equal(PowerUnit.Femtowatt, femtowattQuantity.Unit); var gigajouleperhourQuantity = watt.ToUnit(PowerUnit.GigajoulePerHour); AssertEx.EqualTolerance(GigajoulesPerHourInOneWatt, (double)gigajouleperhourQuantity.Value, GigajoulesPerHourTolerance); Assert.Equal(PowerUnit.GigajoulePerHour, gigajouleperhourQuantity.Unit); var gigawattQuantity = watt.ToUnit(PowerUnit.Gigawatt); AssertEx.EqualTolerance(GigawattsInOneWatt, (double)gigawattQuantity.Value, GigawattsTolerance); Assert.Equal(PowerUnit.Gigawatt, gigawattQuantity.Unit); var hydraulichorsepowerQuantity = watt.ToUnit(PowerUnit.HydraulicHorsepower); AssertEx.EqualTolerance(HydraulicHorsepowerInOneWatt, (double)hydraulichorsepowerQuantity.Value, HydraulicHorsepowerTolerance); Assert.Equal(PowerUnit.HydraulicHorsepower, hydraulichorsepowerQuantity.Unit); var jouleperhourQuantity = watt.ToUnit(PowerUnit.JoulePerHour); AssertEx.EqualTolerance(JoulesPerHourInOneWatt, (double)jouleperhourQuantity.Value, JoulesPerHourTolerance); Assert.Equal(PowerUnit.JoulePerHour, jouleperhourQuantity.Unit); var kilobritishthermalunitperhourQuantity = watt.ToUnit(PowerUnit.KilobritishThermalUnitPerHour); AssertEx.EqualTolerance(KilobritishThermalUnitsPerHourInOneWatt, (double)kilobritishthermalunitperhourQuantity.Value, KilobritishThermalUnitsPerHourTolerance); Assert.Equal(PowerUnit.KilobritishThermalUnitPerHour, kilobritishthermalunitperhourQuantity.Unit); var kilojouleperhourQuantity = watt.ToUnit(PowerUnit.KilojoulePerHour); AssertEx.EqualTolerance(KilojoulesPerHourInOneWatt, (double)kilojouleperhourQuantity.Value, KilojoulesPerHourTolerance); Assert.Equal(PowerUnit.KilojoulePerHour, kilojouleperhourQuantity.Unit); var kilowattQuantity = watt.ToUnit(PowerUnit.Kilowatt); AssertEx.EqualTolerance(KilowattsInOneWatt, (double)kilowattQuantity.Value, KilowattsTolerance); Assert.Equal(PowerUnit.Kilowatt, kilowattQuantity.Unit); var mechanicalhorsepowerQuantity = watt.ToUnit(PowerUnit.MechanicalHorsepower); AssertEx.EqualTolerance(MechanicalHorsepowerInOneWatt, (double)mechanicalhorsepowerQuantity.Value, MechanicalHorsepowerTolerance); Assert.Equal(PowerUnit.MechanicalHorsepower, mechanicalhorsepowerQuantity.Unit); var megajouleperhourQuantity = watt.ToUnit(PowerUnit.MegajoulePerHour); AssertEx.EqualTolerance(MegajoulesPerHourInOneWatt, (double)megajouleperhourQuantity.Value, MegajoulesPerHourTolerance); Assert.Equal(PowerUnit.MegajoulePerHour, megajouleperhourQuantity.Unit); var megawattQuantity = watt.ToUnit(PowerUnit.Megawatt); AssertEx.EqualTolerance(MegawattsInOneWatt, (double)megawattQuantity.Value, MegawattsTolerance); Assert.Equal(PowerUnit.Megawatt, megawattQuantity.Unit); var metrichorsepowerQuantity = watt.ToUnit(PowerUnit.MetricHorsepower); AssertEx.EqualTolerance(MetricHorsepowerInOneWatt, (double)metrichorsepowerQuantity.Value, MetricHorsepowerTolerance); Assert.Equal(PowerUnit.MetricHorsepower, metrichorsepowerQuantity.Unit); var microwattQuantity = watt.ToUnit(PowerUnit.Microwatt); AssertEx.EqualTolerance(MicrowattsInOneWatt, (double)microwattQuantity.Value, MicrowattsTolerance); Assert.Equal(PowerUnit.Microwatt, microwattQuantity.Unit); var millijouleperhourQuantity = watt.ToUnit(PowerUnit.MillijoulePerHour); AssertEx.EqualTolerance(MillijoulesPerHourInOneWatt, (double)millijouleperhourQuantity.Value, MillijoulesPerHourTolerance); Assert.Equal(PowerUnit.MillijoulePerHour, millijouleperhourQuantity.Unit); var milliwattQuantity = watt.ToUnit(PowerUnit.Milliwatt); AssertEx.EqualTolerance(MilliwattsInOneWatt, (double)milliwattQuantity.Value, MilliwattsTolerance); Assert.Equal(PowerUnit.Milliwatt, milliwattQuantity.Unit); var nanowattQuantity = watt.ToUnit(PowerUnit.Nanowatt); AssertEx.EqualTolerance(NanowattsInOneWatt, (double)nanowattQuantity.Value, NanowattsTolerance); Assert.Equal(PowerUnit.Nanowatt, nanowattQuantity.Unit); var petawattQuantity = watt.ToUnit(PowerUnit.Petawatt); AssertEx.EqualTolerance(PetawattsInOneWatt, (double)petawattQuantity.Value, PetawattsTolerance); Assert.Equal(PowerUnit.Petawatt, petawattQuantity.Unit); var picowattQuantity = watt.ToUnit(PowerUnit.Picowatt); AssertEx.EqualTolerance(PicowattsInOneWatt, (double)picowattQuantity.Value, PicowattsTolerance); Assert.Equal(PowerUnit.Picowatt, picowattQuantity.Unit); var terawattQuantity = watt.ToUnit(PowerUnit.Terawatt); AssertEx.EqualTolerance(TerawattsInOneWatt, (double)terawattQuantity.Value, TerawattsTolerance); Assert.Equal(PowerUnit.Terawatt, terawattQuantity.Unit); var wattQuantity = watt.ToUnit(PowerUnit.Watt); AssertEx.EqualTolerance(WattsInOneWatt, (double)wattQuantity.Value, WattsTolerance); Assert.Equal(PowerUnit.Watt, wattQuantity.Unit); }
public void DurationTimesPowerEqualsEnergy() { Energy energy = Duration.FromSeconds(8.0) * Power.FromWatts(5.0); Assert.Equal(energy, Energy.FromJoules(40.0)); }
public void PowerDividedByRotationalSpeedEqualsForce() { Torque torque = Power.FromWatts(15.0) / RotationalSpeed.FromRadiansPerSecond(3); Assert.Equal(torque, Torque.FromNewtonMeters(5)); }
public async Task AddPowerAsync(Power power) { await _context.Powers.AddAsync(power); await _context.SaveChangesAsync(); }
public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() { var quantity00 = Power.From(1, PowerUnit.BoilerHorsepower); AssertEx.EqualTolerance(1, quantity00.BoilerHorsepower, BoilerHorsepowerTolerance); Assert.Equal(PowerUnit.BoilerHorsepower, quantity00.Unit); var quantity01 = Power.From(1, PowerUnit.BritishThermalUnitPerHour); AssertEx.EqualTolerance(1, quantity01.BritishThermalUnitsPerHour, BritishThermalUnitsPerHourTolerance); Assert.Equal(PowerUnit.BritishThermalUnitPerHour, quantity01.Unit); var quantity02 = Power.From(1, PowerUnit.Decawatt); AssertEx.EqualTolerance(1, quantity02.Decawatts, DecawattsTolerance); Assert.Equal(PowerUnit.Decawatt, quantity02.Unit); var quantity03 = Power.From(1, PowerUnit.Deciwatt); AssertEx.EqualTolerance(1, quantity03.Deciwatts, DeciwattsTolerance); Assert.Equal(PowerUnit.Deciwatt, quantity03.Unit); var quantity04 = Power.From(1, PowerUnit.ElectricalHorsepower); AssertEx.EqualTolerance(1, quantity04.ElectricalHorsepower, ElectricalHorsepowerTolerance); Assert.Equal(PowerUnit.ElectricalHorsepower, quantity04.Unit); var quantity05 = Power.From(1, PowerUnit.Femtowatt); AssertEx.EqualTolerance(1, quantity05.Femtowatts, FemtowattsTolerance); Assert.Equal(PowerUnit.Femtowatt, quantity05.Unit); var quantity06 = Power.From(1, PowerUnit.GigajoulePerHour); AssertEx.EqualTolerance(1, quantity06.GigajoulesPerHour, GigajoulesPerHourTolerance); Assert.Equal(PowerUnit.GigajoulePerHour, quantity06.Unit); var quantity07 = Power.From(1, PowerUnit.Gigawatt); AssertEx.EqualTolerance(1, quantity07.Gigawatts, GigawattsTolerance); Assert.Equal(PowerUnit.Gigawatt, quantity07.Unit); var quantity08 = Power.From(1, PowerUnit.HydraulicHorsepower); AssertEx.EqualTolerance(1, quantity08.HydraulicHorsepower, HydraulicHorsepowerTolerance); Assert.Equal(PowerUnit.HydraulicHorsepower, quantity08.Unit); var quantity09 = Power.From(1, PowerUnit.JoulePerHour); AssertEx.EqualTolerance(1, quantity09.JoulesPerHour, JoulesPerHourTolerance); Assert.Equal(PowerUnit.JoulePerHour, quantity09.Unit); var quantity10 = Power.From(1, PowerUnit.KilobritishThermalUnitPerHour); AssertEx.EqualTolerance(1, quantity10.KilobritishThermalUnitsPerHour, KilobritishThermalUnitsPerHourTolerance); Assert.Equal(PowerUnit.KilobritishThermalUnitPerHour, quantity10.Unit); var quantity11 = Power.From(1, PowerUnit.KilojoulePerHour); AssertEx.EqualTolerance(1, quantity11.KilojoulesPerHour, KilojoulesPerHourTolerance); Assert.Equal(PowerUnit.KilojoulePerHour, quantity11.Unit); var quantity12 = Power.From(1, PowerUnit.Kilowatt); AssertEx.EqualTolerance(1, quantity12.Kilowatts, KilowattsTolerance); Assert.Equal(PowerUnit.Kilowatt, quantity12.Unit); var quantity13 = Power.From(1, PowerUnit.MechanicalHorsepower); AssertEx.EqualTolerance(1, quantity13.MechanicalHorsepower, MechanicalHorsepowerTolerance); Assert.Equal(PowerUnit.MechanicalHorsepower, quantity13.Unit); var quantity14 = Power.From(1, PowerUnit.MegajoulePerHour); AssertEx.EqualTolerance(1, quantity14.MegajoulesPerHour, MegajoulesPerHourTolerance); Assert.Equal(PowerUnit.MegajoulePerHour, quantity14.Unit); var quantity15 = Power.From(1, PowerUnit.Megawatt); AssertEx.EqualTolerance(1, quantity15.Megawatts, MegawattsTolerance); Assert.Equal(PowerUnit.Megawatt, quantity15.Unit); var quantity16 = Power.From(1, PowerUnit.MetricHorsepower); AssertEx.EqualTolerance(1, quantity16.MetricHorsepower, MetricHorsepowerTolerance); Assert.Equal(PowerUnit.MetricHorsepower, quantity16.Unit); var quantity17 = Power.From(1, PowerUnit.Microwatt); AssertEx.EqualTolerance(1, quantity17.Microwatts, MicrowattsTolerance); Assert.Equal(PowerUnit.Microwatt, quantity17.Unit); var quantity18 = Power.From(1, PowerUnit.MillijoulePerHour); AssertEx.EqualTolerance(1, quantity18.MillijoulesPerHour, MillijoulesPerHourTolerance); Assert.Equal(PowerUnit.MillijoulePerHour, quantity18.Unit); var quantity19 = Power.From(1, PowerUnit.Milliwatt); AssertEx.EqualTolerance(1, quantity19.Milliwatts, MilliwattsTolerance); Assert.Equal(PowerUnit.Milliwatt, quantity19.Unit); var quantity20 = Power.From(1, PowerUnit.Nanowatt); AssertEx.EqualTolerance(1, quantity20.Nanowatts, NanowattsTolerance); Assert.Equal(PowerUnit.Nanowatt, quantity20.Unit); var quantity21 = Power.From(1, PowerUnit.Petawatt); AssertEx.EqualTolerance(1, quantity21.Petawatts, PetawattsTolerance); Assert.Equal(PowerUnit.Petawatt, quantity21.Unit); var quantity22 = Power.From(1, PowerUnit.Picowatt); AssertEx.EqualTolerance(1, quantity22.Picowatts, PicowattsTolerance); Assert.Equal(PowerUnit.Picowatt, quantity22.Unit); var quantity23 = Power.From(1, PowerUnit.Terawatt); AssertEx.EqualTolerance(1, quantity23.Terawatts, TerawattsTolerance); Assert.Equal(PowerUnit.Terawatt, quantity23.Unit); var quantity24 = Power.From(1, PowerUnit.Watt); AssertEx.EqualTolerance(1, quantity24.Watts, WattsTolerance); Assert.Equal(PowerUnit.Watt, quantity24.Unit); }
public async Task UpdatePowerAsync(Power power) { _context.Powers.Update(power); await _context.SaveChangesAsync(); }
public void PowerTimesBrakeSpecificFuelConsumptionEqualsMassFlow() { MassFlow massFlow = Power.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0) * BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(180.0); AssertEx.EqualTolerance(massFlow.TonnesPerDay, 20.0, 1e-11); }
public void EqualsReturnsFalseOnNull() { Power watt = Power.FromWatts(1); Assert.False(watt.Equals(null)); }
public void PowerTimesTimeSpanEqualsEnergy() { Energy energy = Power.FromWatts(5.0) * TimeSpan.FromSeconds(8.0); Assert.Equal(energy, Energy.FromJoules(40.0)); }
public void PowerDividedBySpecificEnergyEqualsMassFlow() { MassFlow massFlow = Power.FromWatts(15.0) / SpecificEnergy.FromJoulesPerKilogram(3); Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(5)); }
public void GetHashCode_Equals() { var quantity = Power.FromWatts(1.0); Assert.Equal(new { Power.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode()); }
public void ToString_NullProvider_EqualsCurrentUICulture() { var quantity = Power.FromWatts(1.0); Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g")); }