public void ToString_3()
 {
    var amt = new Amount("usd", -122M);
                          
    Console.WriteLine(amt);    
    Assert.AreEqual("-122:usd", amt.ToString());    
 }

 public IngredientUsage(Ingredient ingredient, IngredientForm form, Amount amount, string prepnote)
 {
     Ingredient = ingredient;
     Form = form;
     Amount = amount;
     PrepNote = prepnote;
 }

        public static bool RelevantTransaction(WalletTransaction tx, Account account, out Amount debit, out Amount credit)
        {
            if (tx == null)
                throw new ArgumentNullException(nameof(tx));

            debit = 0;
            credit = 0;
            var relevant = false;

            foreach (var input in tx.Inputs)
            {
                if (input.PreviousAccount == account)
                {
                    relevant = true;
                    debit -= input.Amount;
                }
            }
            foreach (var output in tx.Outputs)
            {
                var controlledOutput = output as WalletTransaction.Output.ControlledOutput;
                if (controlledOutput?.Account == account)
                {
                    relevant = true;
                    credit += output.Amount;
                }
            }

            return relevant;
        }

 public IngredientUsage(Ingredient ingredient, IngredientForm form, Amount amount, string preparationNote)
 {
     this.Ingredient = ingredient;
     this.Form = form;
     this.Amount = amount;
     this.PreparationNote = preparationNote;
 }

        public void TestAmounts()
        {
            var amt1 = new Amount(0.5f, 1f, Units.Teaspoon);
             var amt2 = new Amount(0.75f, Units.Pound);

             //Test equals
             Assert.AreEqual(new Amount(0.5f, 1f, Units.Teaspoon), amt1);
             Assert.AreEqual(new Amount(0.75f, Units.Pound), amt2);

             //Test multiplication
             Assert.AreEqual(new Amount(1f, 2f, Units.Teaspoon), amt1*2);
             Assert.AreEqual(new Amount(1.5f, Units.Pound), amt2*2);

             //Test addition
             Assert.AreEqual(new Amount(2.5f, 3f, Units.Teaspoon), amt1 + 2);
             Assert.AreEqual(new Amount(1f, Units.Pound), amt2 + 0.25f);

             Assert.AreEqual(new Amount(1.5f, 4f, Units.Teaspoon), amt1 + new Amount(1f, 3f, Units.Teaspoon));
             Assert.AreEqual(new Amount(1.5f, 2f, Units.Teaspoon), amt1 + new Amount(1f, Units.Teaspoon));
             Assert.AreEqual(new Amount(1f, Units.Pound), amt2 + new Amount(.25f, Units.Pound));

             //Cross unit addition
             Assert.AreEqual(new Amount(1.5f, 4f, Units.Teaspoon), amt1 + new Amount(.5f, 1f, Units.Tablespoon));
             // Assert.AreEqual(new Amount(3.5f, 4f, Units.Teaspoon), amt1 + new Amount(1f, Units.Tablespoon)); //Adding 3tsp
             Assert.AreEqual(new Amount(1f, Units.Pound), amt2 + new Amount(4f, Units.Ounce));

             //Test division
             Assert.AreEqual(new Amount(.25f, .5f, Units.Teaspoon), amt1/2);
             Assert.AreEqual(new Amount(.25f, Units.Pound), amt2/3);

             //Test subtraction
             Assert.AreEqual(new Amount(.25f, .75f, Units.Teaspoon), amt1 - .25f);
             Assert.AreEqual(new Amount(.25f, Units.Pound), amt2 - 0.50f);
        }

 protected RealExTransactionRequest(string secret, string merchantId, string account, string orderId, Amount amount, Card card, Comments comments)
     : base(secret, merchantId, account, orderId, comments)
 {
     SignatureProperties = () => new[] { Amount.Value.ToString(), Amount.Currency.CurrencyName(), Card.Number };
     Amount = amount;
     Card = card;
 }

        public IngredientAdder AddIngredient(Ingredient ingredient, Amount amount, string prepNote = null)
        {
            var usage = new IngredientUsage(ingredient, null, amount, prepNote);
            var addedIngredient = this.AddIngredientUsage(usage);

            return addedIngredient;
        }

 public void ToString_1()
 {
    var amt = new Amount("usd", 12.45M);
                          
    Console.WriteLine(amt);    
    Assert.AreEqual("12.45:usd", amt.ToString());    
 }

 public RealEx3DVerifyRequest(string secret, string merchantId, string account, string orderId, Amount amount, Card card, string paRes, Comments comments)
     : base(secret, merchantId, account, orderId, amount, card, comments)
 {
     PaRes = paRes;
     Type = "3ds-verifysig";
     IsSecure = true;
 }

 public Investment(Investor investor, Venture venture, Amount amount)
 {
     this.investor = investor;
     this.venture = venture;
     this.Value = amount;
     this.venture = venture;
 }

                public UncontrolledOutput(Amount amount, byte[] pkScript) : base(amount)
                {
                    if (pkScript == null)
                        throw new ArgumentNullException(nameof(pkScript));

                    PkScript = OutputScript.ParseScript(pkScript);
                }

        public CashWithdrawnEvent(Guid id, Balance balance, Amount amount)
        {

            Id = id;
            DateTimeEventOccurred = DateTime.UtcNow;
            Balance = balance;
            Amount = amount;
        }

    /// <summary>
    /// Initializes a new instance of the <see cref="Price"/> class.
    /// </summary>
    /// <param name="amount">The amount.</param>
    /// <param name="baseQuantity">The base quantity.</param>
    public Price([NotNull] Amount amount, decimal baseQuantity)
    {
      Assert.ArgumentNotNull(amount, "amount");

      this.amount = amount;
      this.baseQuantity = baseQuantity;
      this.orderableUnitFactorRate = 1;
    }

 public ShoppingListItems(Guid id, Guid userid, Amount amt, Guid? ingredientId, Guid? recipeId)
 {
     this.ItemId = id;
     this.UserId = userid;
     this.Amount = amt;
     this.Ingredient = ingredientId.HasValue ? Ingredients.FromId(ingredientId.Value) : null;
     this.Recipe = recipeId.HasValue ? Recipes.FromId(recipeId.Value) : null;
 }

 public UnspentOutput(Sha256Hash txHash, uint outputIndex, Amount amount, OutputScript pkScript, DateTimeOffset seenTime, bool isFromCoinbase)
 {
     TransactionHash = txHash;
     OutputIndex = outputIndex;
     Amount = amount;
     PkScript = pkScript;
     SeenTime = seenTime;
     IsFromCoinbase = IsFromCoinbase;
 }

 public override ITaxStructured DoCalc(
     TaxSession session,
     IAddress fromAddress, 
     IAddress toAddress, 
     Amount amount, 
     Amount shipping)
 {
   return DoCalc(session as TaxJarSession, fromAddress, toAddress, amount, shipping);
 }

 public WalletTransaction(Transaction transaction, Sha256Hash hash, Input[] inputs, Output[] outputs, Amount? fee, DateTimeOffset seenTime)
 {
     Hash = hash;
     Inputs = inputs;
     Outputs = outputs;
     Fee = fee;
     Transaction = transaction;
     SeenTime = seenTime;
 }

		public void Sum01Test()
		{
			AmountVector v = new AmountVector(4, LengthUnits.Meter);
			v[0] = new Amount(150m, LengthUnits.Meter);
			v[2] = new Amount(0.2m, LengthUnits.KiloMeter);
			v[3] = new Amount(650m, LengthUnits.Meter);

			Assert.AreEqual(new Amount(1m, LengthUnits.KiloMeter), v.Sum);
		}

 public override ITaxStructured DoCalc(
     TaxSession session,
     IAddress fromAddress, 
     IAddress toAddress, 
     Amount amount, 
     Amount shipping)
 {
   return TaxStructured.NoneInstance;
 }

        /// <summary>
        /// Constructs an unsigned transaction by referencing previous unspent outputs.
        /// A change output is added when necessary to return extra value back to the wallet.
        /// </summary>
        /// <param name="outputs">Transaction output array without change.</param>
        /// <param name="changeScript">Output script to pay change to.</param>
        /// <param name="fetchInputsAsync">Input selection source.</param>
        /// <returns>Unsigned transaction and total input amount.</returns>
        /// <exception cref="InsufficientFundsException">Input source was unable to provide enough input value.</exception>
        public static async Task<Tuple<Transaction, Amount>> BuildUnsignedTransaction(Transaction.Output[] outputs,
                                                                                      Amount feePerKb,
                                                                                      InputSource fetchInputsAsync,
                                                                                      ChangeSource fetchChangeAsync)
        {
            if (outputs == null)
                throw new ArgumentNullException(nameof(outputs));
            if (fetchInputsAsync == null)
                throw new ArgumentNullException(nameof(fetchInputsAsync));
            if (fetchChangeAsync == null)
                throw new ArgumentNullException(nameof(fetchChangeAsync));

            var targetAmount = outputs.Sum(o => o.Amount);
            var estimatedSize = Transaction.EstimateSerializeSize(1, outputs, true);
            var targetFee = TransactionFees.FeeForSerializeSize(feePerKb, estimatedSize);

            while (true)
            {
                var funding = await fetchInputsAsync(targetAmount + targetFee);
                var inputAmount = funding.Item1;
                var inputs = funding.Item2;
                if (inputAmount < targetAmount + targetFee)
                {
                    throw new InsufficientFundsException();
                }

                var maxSignedSize = Transaction.EstimateSerializeSize(inputs.Length, outputs, true);
                var maxRequiredFee = TransactionFees.FeeForSerializeSize(feePerKb, maxSignedSize);
                var remainingAmount = inputAmount - targetAmount;
                if (remainingAmount < maxRequiredFee)
                {
                    targetFee = maxRequiredFee;
                    continue;
                }

                var unsignedTransaction = new Transaction(Transaction.SupportedVersion, inputs, outputs, 0, 0);
                var changeAmount = inputAmount - targetAmount - maxRequiredFee;
                if (changeAmount != 0 && !TransactionRules.IsDustAmount(changeAmount, Transaction.PayToPubKeyHashPkScriptSize, feePerKb))
                {
                    var changeScript = await fetchChangeAsync();
                    if (changeScript.Script.Length > Transaction.PayToPubKeyHashPkScriptSize)
                    {
                        throw new Exception("Fee estimation requires change scripts no larger than P2PKH output scripts");
                    }
                    var changeOutput = new Transaction.Output(changeAmount, Transaction.Output.LatestPkScriptVersion, changeScript.Script);

                    var outputList = unsignedTransaction.Outputs.ToList();
                    outputList.Add(changeOutput);
                    var outputsWithChange = outputList.ToArray();

                    unsignedTransaction = new Transaction(unsignedTransaction.Version, unsignedTransaction.Inputs, outputsWithChange,
                        unsignedTransaction.LockTime, unsignedTransaction.Expiry);
                }

                return Tuple.Create(unsignedTransaction, inputAmount);
            }
        }