private EntityCollection GenerateRandomAccountCollection()
        {
            var collection = new List<Entity>();
            for (var i = 0; i < 10; i++)
            {
                var rgn = new Random((int)DateTime.Now.Ticks);
                var entity = new Entity("account");
                entity["accountid"] = entity.Id = Guid.NewGuid();
                entity["address1_addressid"] = Guid.NewGuid();
                entity["modifiedon"] = DateTime.Now;
                entity["lastusedincampaign"] = DateTime.Now;
                entity["donotfax"] = rgn.NextBoolean();
                entity["new_verybignumber"] = rgn.NextInt64();
                entity["exchangerate"] = rgn.NextDecimal();
                entity["address1_latitude"] = rgn.NextDouble();
                entity["numberofemployees"] = rgn.NextInt32();
                entity["primarycontactid"] = new EntityReference("contact", Guid.NewGuid());
                entity["revenue"] = new Money(rgn.NextDecimal());
                entity["ownerid"] = new EntityReference("systemuser", Guid.NewGuid());
                entity["industrycode"] = new OptionSetValue(rgn.NextInt32());
                entity["name"] = rgn.NextString(15);
                entity["description"] = rgn.NextString(300);
                entity["statecode"] = new OptionSetValue(rgn.NextInt32());
                entity["statuscode"] = new OptionSetValue(rgn.NextInt32());
                collection.Add(entity);
            }

            return new EntityCollection(collection);
        }

 public void DivisionOfMoneyObejcts_ShouldReturnWallet()
 {
     var money1 = new Money<long>(42);
     var money2 = new Money<long>(1000);
     var actual = money1 / money2;
     actual.ShouldBeAssignableTo<Wallet<long>>();
 }

        public void MoneyHasValueEquality()
        {
            var money1 = new Money(101.5M);
            var money2 = new Money(101.5M);

            money2.ShouldBe(money1);
        }

        internal Money Round(Money money, int decimalPlaces)
        {
            decimal amount = money.Amount;
            int factor = (int) Math.Pow(10, decimalPlaces);

            // split the amount into integral and fraction parts
            decimal integral = Math.Truncate(money.Amount);
            decimal fraction = amount-integral;

            // raise the fraction by the number of decimal places to which we want to round,
            // so that we can apply integer rounding
            decimal raisedFraction = Decimal.Multiply(fraction, factor);

            // pass the raisedFraction to a template method to do the rounding according to the RoundingStrategy
            decimal roundedFraction = CalculateRoundedAmount(raisedFraction);

            // shift the decimal to the left again, by the number of decimal places
            decimal resultFraction = Decimal.Divide(roundedFraction, factor);

            // add the original integral and the rounded resultFraction back together
            decimal roundedAmount = integral + resultFraction;

            // return the result
            return new Money(money.Currency, roundedAmount, money.RoundingMode, (DecimalPlaces)money.DecimalPlaces);
        }

        public void MoneyFractionalAmountWithOverflowAdditionIsCorrect()
        {
            var money1 = new Money(100.999M);
            var money2 = new Money(0.9M);

            Assert.Equal(new Money(101.899m), money1 + money2);
        }

        public void MoneyFractionalAmountAdditionIsCorrect()
        {
            var money1 = new Money(100.00m);
            var money2 = new Money(0.01m);

            Assert.Equal(new Money(100.01m), money1 + money2);
        }

 public override void DataBind()
 {
     var splitLineItems = Shipment.GetShipmentLineItems(SplitShipment);
     var billingCurrency = CartHelper.Cart.BillingCurrency;
     if (splitLineItems != null)
     {
         OrderSubTotalLineItems.Text = new Money(splitLineItems.ToArray().Sum(x => x.ExtendedPrice) +
             splitLineItems.ToArray().Sum(x => x.OrderLevelDiscountAmount), billingCurrency).ToString();
     }
     if (SplitShipment != null)
     {
         string discountMessage = String.Empty;
         var shippingDiscountsTotal = CalculateShippingDiscounts(SplitShipment, billingCurrency, out discountMessage);
         var shippingCostSubTotal = CalculateShippingCostSubTotal(SplitShipment, CartHelper);
         shippingDiscount.Text = shippingDiscountsTotal.ToString();
         ShippingDiscountsMessage.Text = discountMessage;
         shippingTotal.Text = (shippingCostSubTotal).ToString();
     }
     else
     {
         string zeroMoney = new Money(0, SiteContext.Current.Currency).ToString();
         shippingDiscount.Text = zeroMoney;
         shippingTotal.Text = zeroMoney;
     }
 }

 public Transfer makeTransfer(string counterAccount, Money amount)
 {
     // 1. Assuming result is 9-digit bank account number, validate 11-test:
     int sum = 0; // <1>
     for (int i = 0; i < counterAccount.Length; i++)
     {
         sum = sum + (9 - i) * (int)Char.GetNumericValue(
             counterAccount[i]);
     }
     if (sum % 11 == 0)
     {
         // 2. Look up counter account and make transfer object:
         CheckingAccount acct = Accounts.FindAcctByNumber(counterAccount);
         Transfer result = new Transfer(this, acct, amount); // <2>
         // 3. Check whether withdrawal is to registered counter account:
         if (result.CounterAccount.Equals(this.RegisteredCounterAccount))
         {
             return result;
         }
         else
         {
             throw new BusinessException("Counter-account not registered!");
         }
     }
     else
     {
         throw new BusinessException("Invalid account number!!");
     }
 }

        public void CurrencyCodeShouldBeCaseIgnorant(string currency)
        {
            const Currency expectedCurrency = Currency.AUD;
            var money = new Money(42, currency);

            money.Currency.ShouldBe(expectedCurrency);
        }

 public void WhenDestinationCurrencyIsEmpty_ShouldThrow()
 {
     var m1 = new Money<decimal>(123, "USD");
     var m2 = new Money<decimal>(1, "AUD");
     var wallet = m1 + m2;
     Should.Throw<ArgumentNullException>(() => wallet.Evaluate(this.currencyConverter, null));
 }

 public void WhenCurrencyConverterIsNull_ShouldThrow()
 {
     var m1 = new Money<int>(123, "USD");
     var m2 = new Money<int>(1, "AUD");
     var wallet = m1 + m2;
     Should.Throw<ArgumentNullException>(() => wallet.Evaluate(null, "AUD"));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Instruments.Price">Price</see> class.
 /// </summary>
 /// <param name="money">This is the amount that one particular instrument to which the price belongs would cost</param>
 /// <param name="instrument">The instrument to which the price belongs</param>
 public Price(Money money, IInstrument instrument)
 {
     this.quantity = money.Quantity;
     this.underlying = (ICurrency)money.Underlying;
     this.instrument = instrument;
     this.XRate = money.XRate;
 }

        public void opInequality_Money_Money()
        {
            var obj = new Money(new Currency("€", 2), 1.23m);
            var comparand = new Money(new Currency("£", 2), 1.23m);

            Assert.True(obj != comparand);
        }

        public void Bid(Guid auctionId, Guid memberId, decimal amount)
        {
            try
            {
                using (DomainEvents.Register(OutBid()))
                using (DomainEvents.Register(BidPlaced()))
                {
                    var auction = _auctionRepository.FindBy(auctionId);

                    var bidAmount = new Money(amount);

                    auction.PlaceBidFor(new Bid(memberId, bidAmount, _clock.Time()), _clock.Time());

                    _auctionRepository.Save(auction);
                }

                _unitOfWork.Commit();
            }
            catch (ConcurrencyException ex)
            {
                _unitOfWork.Clear();

                Bid(auctionId, memberId, amount);
            }            
        }

 public void AdditionOfMoneyObejcts_ShouldReturnWallet()
 {
     var money1 = new Money<int>(42);
     var money2 = new Money<int>(1000);
     var actual = money1 + money2;
     actual.ShouldBeAssignableTo<Wallet<int>>();
 }

		public void TestOperations()
		{
			var money1 = new Money(12.34, CurrencyCodes.USD);
			var money2 = new Money(12.34, CurrencyCodes.ZAR);
			Money.Converter = new ConverterMock();
			Money.AllowImplicitConversion = true;

			// adding oranges to apples gives you apples
			var money3 = money1 + money2;
			Assert.AreEqual("USD", money3.CurrencyCode);

            // left side is ZAR and right side is USD, money3 gets converted back to ZAR
            // the same converter should return the same inverted rates
            var m1To3 = Money.Converter.GetRate(money1.CurrencyCode, money3.CurrencyCode, DateTime.Now);
            var m3To1 = Money.Converter.GetRate(money3.CurrencyCode, money1.CurrencyCode, DateTime.Now);
            if (m1To3 == 1d / m3To1)
                Assert.AreEqual(money2, money3 - money1);
            else
                Assert.AreNotEqual(money2, money3 - money1);
            // Mix up ZAR and USD. moneys converted only one way
            Assert.AreEqual(money1, money3 - money2);

			// Should fail if allowImplicitconversion is false (default)
			Money.AllowImplicitConversion = false;
			try
			{
				money3 = money1 + money2;
				Assert.Fail("Money type exception was not thrown:" + money3.Amount);
			}
			catch (InvalidOperationException e)
			{
				Assert.AreEqual("Money type mismatch", e.Message);
			}
		}

 public void ValidateDeposit(Money amount)
 {
     if (amount > _maximumDepositAllowed)
     {
         throw new ArgumentOutOfRangeException(string.Format("Deposits over {0} are not allowed", _maximumDepositAllowed));
     }
 }

 public static Money NinetyPercentOf(Money amount)
 {
     return amount
         .Distribute(10)
         .Take(9)
         .Sum(m => m.Amount);
 }

    /// <summary>
    /// Runs the code example.
    /// </summary>
    /// <param name="user">The AdWords user.</param>
    /// <param name="businessId">The AdWords Express business id.</param>
    /// <param name="promotionId">The promotion id.</param>
    public void Run(AdWordsUser user, long businessId, long promotionId) {
      // Get the ExpressBusinessService.
      ExpressBusinessService businessService = (ExpressBusinessService)
          user.GetService(AdWordsService.v201509.ExpressBusinessService);

      // Get the PromotionService
      PromotionService promotionService = (PromotionService)
          user.GetService(AdWordsService.v201509.PromotionService);

      // Set the business ID to the service.
      promotionService.RequestHeader.expressBusinessId = businessId;

      // Update the budget for the promotion
      Promotion promotion = new Promotion();
      promotion.id = promotionId;
      Money newBudget = new Money();
      newBudget.microAmount = 2000000;
      promotion.budget = newBudget;

      PromotionOperation operation = new PromotionOperation();
      [email protected] = Operator.SET;
      operation.operand = promotion;

      try {
        Promotion[] updatedPromotions = promotionService.mutate(
            new PromotionOperation[] { operation });

        Console.WriteLine("Promotion ID {0} for business ID {1} now has budget micro " +
            "amount {2}.", promotionId, businessId,
            updatedPromotions[0].budget.microAmount);
      } catch (Exception e) {
        throw new System.ApplicationException("Failed to update promotions.", e);
      }
    }

 public Contract(Product product, Money revenue, DateTime whenSigned, long id)
 {
     _product = product;
     Revenue = revenue;
     WhenSigned = whenSigned;
     _id = id;
 }