public void MassBothInequality()
        {
            Mass m1 = new Mass(524.342);
            Mass m2 = new Mass(524.343);

            Assert.AreNotEqual(m1, m2);
        }

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

		public void Test_this (double massValue, double secondValue, double expectedValue)
		{
			var _mass = new Mass (MeasurementSystem.InternationalSystemOfUnits, massValue);
			var _second = new Mass (MeasurementSystem.InternationalSystemOfUnits, secondValue);
			var _sum = _mass + _second;
			Assert.AreEqual (expectedValue, _sum [MeasurementSystem.InternationalSystemOfUnits]);
		}

 public void ConvertToSi(Mass m, string dimension)
 {
     if (dimension != "kg")
     {
         if (dimension == "t")
         {
             m.Value *= 1000;
         }
         else if (dimension == "sl")
         {
             m.Value *= 14.6;
         }
         else if (dimension == "Ib")
         {
             m.Value *= 0.45;
         }
         else if (dimension == "g")
         {
             m.Value /= 1000;
         }
         else if (dimension == "mg")
         {
             m.Value /= 1000000000;
         }
         else
         {
             throw new IncorrectDimensionOfMassException();
         }
     }
 }

        public void MassEquality()
        {
            Mass m1 = new Mass(524.342);
            Mass m2 = new Mass(524.342);

            Assert.AreEqual(m1, m2);
        }

 [Test] public void can_use_mass_volume_constructor() {
     Mass m = new Mass(10, MassUnit.Pounds);
     Volume v = new Volume(2, VolumeUnit.Gallons);
     var d = new Density(m, v);
     d.Mass.ShouldEqual(m);
     d.Volume.ShouldEqual(v);
 }

        public void MassObjectToMzNegativeCharge()
        {
            Mass m1 = new Mass(1000);
            double mz = m1.ToMz(-2);

            Assert.AreEqual(498.99272353318798, mz);
        }

        public void MassMonoisotopicInequality()
        {
            Mass m1 = new Mass(524.342);
            Mass m2 = new Mass(524.343);

            Assert.AreNotEqual(m1, m2);
        }

        public void ConstructorIMassRefInequality()
        {
            IMass m = new Mass(524.342);
            Mass m2 = new Mass(m);

            Assert.AreNotSame(m, m2);
        }

        public void ConstructorIMass()
        {
            IMass m = new Mass(524.342);
            Mass m2 = new Mass(m);

            Assert.AreEqual(m, m2);
        }

 public void OpAddition()
 {
     var mass1 = new Mass(2000, MassUnit.Gram);
     var mass2 = new Mass(1, MassUnit.Kilogram);
     var expected = new Mass(3000, MassUnit.Gram);
     (mass1 + mass2).ShouldEqual(expected);
     (mass2 + mass1).ShouldEqual(expected);
 }

 public Mass Convert(Mass from, MassUnit to) {
     if (from.Unit.Equals(to))
         return new Mass(from.Amount, to);
     var tfs = new FromToConversion(from.Unit, to);
     if(!_knownConversions.ContainsKey(tfs))
         throw new NotImplementedException("This conversion has not yet been implemented");
     return new Mass(from.Amount * _knownConversions[tfs], to);
 }

 private void pictureBox1_MouseClick(object sender, MouseEventArgs e)
 {
     Mass m = new Mass(e.Location.X, e.Location.Y, Int32.Parse(textBox1.Text));
     lista.Add(m);
     reloadPicture();
     //tu bedzie reloadPicture() z wyliczeniem kropek i potem linii
     reloadPotencjal();
     pictureBox1.Refresh();
     reloadBox();
 }

 public void OpInverseEquals()
 {
     var mass1 = new Mass(3000, MassUnit.Gram);
     var mass2 = new Mass(3, MassUnit.Kilogram);
     var mass3 = new Mass(4, MassUnit.Kilogram);
     (mass1 != mass2).ShouldBeFalse();
     (mass2 != mass1).ShouldBeFalse();
     (mass1 != mass3).ShouldBeTrue();
     (mass3 != mass1).ShouldBeTrue();
 }

 public void OpGreaterThanOrEqual()
 {
     var mass1 = new Mass(3000, MassUnit.Gram);
     var mass2 = new Mass(3, MassUnit.Kilogram);
     var mass3 = new Mass(4, MassUnit.Kilogram);
     (mass1 >= mass3).ShouldBeFalse();
     (mass3 >= mass1).ShouldBeTrue();
     (mass1 >= mass2).ShouldBeTrue();
     (mass2 >= mass1).ShouldBeTrue();
 }

        public void OpDivision()
        {
            var mass1 = new Mass(2000, MassUnit.Gram);
            var mass2 = new Mass(2, MassUnit.Kilogram);
            (mass1 / mass2).ShouldBeWithinEpsilonOf(1);
            (mass2 / mass1).ShouldBeWithinEpsilonOf(1);

            (mass1 / 2).ShouldEqual(new Mass(1000, MassUnit.Gram));
            (mass2 / 2).ShouldEqual(new Mass(1, MassUnit.Kilogram));
        }

 public void Start()
 {
     m_hb=this;
     m_AS=(AudioSource)gameObject.GetComponent<AudioSource>();
     m_PS=(ParticleSystem)gameObject.GetComponent<ParticleSystem>();
     m_mass=(Mass)gameObject.GetComponent<Mass>();
     m_curMax=m_baseMax;
     m_curRate=m_baseEmissionRate;
     sm_planetBonus=0;
     sm_score=0;
 }

 public static Vector3 ApplyGravity(Mass body)
 {
     Vector3 totalForces = new Vector3 ();
     foreach (Mass m in m_Gravity.m_masses) {
         if (body != m) {
             Vector3 toVec = m.transform.position - body.transform.position;
             totalForces =totalForces+ Mathf.Sqrt(Mathf.Min(toVec.sqrMagnitude,Mathf.Pow(10,20))*(body.rigidbody.mass+m.rigidbody.mass))*toVec.normalized;
     //				Debug.Log(m.name);
     //				Debug.Log(totalForces+"+ Mathf.Sqrt("+toVec.sqrMagnitude+"*("+body.rigidbody.mass+"+"+m.rigidbody.mass+"))*"+toVec.normalized);
         }
     }
     //		Debug.Log(body.name+totalForces);
     return totalForces;
 }

        private static void Main(string[] args)
        {
            var vehicleMass = new Mass(2500, MassUnit.Pounds);
            var startSpeed = new Speed(72, SpeedUnit.MilesPerHour);
            var endSpeed = new Speed(0, SpeedUnit.MilesPerHour);
            var stoppingDistance = new Length(1234, LengthUnit.Foot);
            Acceleration deceleration = ((endSpeed * endSpeed) - (startSpeed * startSpeed)) / (2 * stoppingDistance);
            Force stoppingForceRequired = vehicleMass * deceleration;

            Console.WriteLine("The stopping force required is:");
            Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.Newtons, 3));
            Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.KilogramForce, 3));
            Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.PoundForce, 3));
            Console.ReadLine();
        }

 public void OpEquals()
 {
     var mass1 = new Mass(3000, MassUnit.Gram);
     var mass2 = new Mass(3, MassUnit.Kilogram);
     var mass3 = new Mass(4, MassUnit.Kilogram);
     (mass1 == mass2).ShouldBeTrue();
     (mass2 == mass1).ShouldBeTrue();
     (mass1 == mass3).ShouldBeFalse();
     (mass3 == mass1).ShouldBeFalse();
     mass1.Equals(mass2)
          .ShouldBeTrue();
     mass1.Equals((object)mass2)
          .ShouldBeTrue();
     mass2.Equals(mass1)
          .ShouldBeTrue();
     mass2.Equals((object)mass1)
          .ShouldBeTrue();
 }