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