public void TestResolveItemsWithJudgements()
{
var testInput = new AmericanEmployment();
var options = new AmericanDomusOpesOptions
{
Inception = DateTime.Today.AddYears(-1),
SumTotal = 75000D
};
testInput.RandomizeAllItems(options);
var testSubject = new AmericanDeductions(testInput);
options.IsPayingChildSupport = true;
testSubject.RandomizeAllItems(options);
Assert.IsNotNull(testSubject.MyItems);
Assert.AreNotEqual(0, testSubject.MyItems.Count);
var testResultItem = testSubject.MyItems.FirstOrDefault(x => x.Name == "Child Support");
Assert.IsNotNull(testResultItem);
Assert.AreNotEqual(0.ToPecuniam(), testResultItem.Value);
Console.WriteLine(testResultItem.Value);
}
public void TestGetEmploymentDeductionName2Rates()
{
var testInput = new AmericanEmployment();
var testSubject = new AmericanDeductions(testInput);
var testOptions =
new AmericanDomusOpesOptions {
Inception = DateTime.Today.AddYears(-1)
};
var testResult = testSubject.GetEmploymentDeductionName2Rates(testOptions);
Assert.IsNotNull(testResult);
Assert.AreNotEqual(0, testResult.Count);
foreach (var tr in testResult)
{
Console.WriteLine(tr);
}
var testResultSum = testResult.Select(kv => kv.Value).Sum();
Assert.AreEqual(1D, Math.Round(testResultSum));
Assert.IsNotNull(testOptions.SumTotal);
Assert.AreNotEqual(0D, testOptions.SumTotal);
Console.WriteLine(testOptions.SumTotal);
}
public void TestDeductionsAllPresent()
{
var testInput = new AmericanEmployment();
var options = new AmericanDomusOpesOptions
{
Inception = DateTime.Today.AddYears(-1),
SumTotal = 75000D
};
testInput.RandomizeAllItems(options);
//check input is good
Assert.IsNotNull(testInput.MyItems);
Assert.AreNotEqual(0, testInput.MyItems.Count);
var diff = Math.Abs(testInput.Total.ToDouble() - 75000);
Console.WriteLine(diff);
Assert.IsTrue(Math.Round(diff) == 0.0D);
var testSubject = new AmericanDeductions(testInput);
testSubject.RandomizeAllItems(null);
var testResults = testSubject.GetAt(DateTime.Today.AddDays(-182));
var allDeductionsItesm = WealthBaseTests.GetExpectedNamesFromXml("deduction");
Assert.IsNotNull(testResults);
Assert.IsNotNull(allDeductionsItesm);
Assert.AreEqual(allDeductionsItesm.Count, testResults.Length);
}
public void TestGetGroupNames2Portions()
{
var testInput = new AmericanEmployment();
var testSubject = new AmericanDeductions(testInput);
var testResults = testSubject.GetGroupNames2Portions(null);
Assert.IsTrue(testResults.Any(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.INSURANCE));
Assert.AreNotEqual(0, testResults.First(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.INSURANCE).Item2);
Assert.IsTrue(testResults.Any(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.EMPLOYMENT));
Assert.AreNotEqual(0, testResults.First(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.EMPLOYMENT).Item2);
Assert.IsTrue(testResults.Any(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.GOVERNMENT));
Assert.AreNotEqual(0, testResults.First(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.GOVERNMENT).Item2);
Assert.IsTrue(testResults.Any(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.JUDGMENTS));
Assert.AreEqual(0, testResults.First(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.JUDGMENTS).Item2);
var testOptions = new AmericanDomusOpesOptions();
testOptions.AddGivenDirectly(AmericanDomusOpesBase.DeductionGroupNames.JUDGMENTS, 1000);
testResults = testSubject.GetGroupNames2Portions(testOptions);
Assert.IsTrue(testResults.Any(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.JUDGMENTS));
Assert.AreNotEqual(0, testResults.First(t => t.Item1 == AmericanDomusOpesBase.DeductionGroupNames.JUDGMENTS).Item2);
}
/// <summary>
/// The reusable\common parts of <see cref="RandomizeAllItems"/>
/// </summary>
/// <param name="grp2Rate"></param>
/// <param name="options"></param>
/// <returns></returns>
protected internal virtual NamedTradeline[] GetItemsForRange(Tuple <string, double> grp2Rate, AmericanDomusOpesOptions options)
{
options = options ?? AmericanDomusOpesOptions.RandomOpesOptions();
var itemsout = new List <NamedTradeline>();
var name2Op = GetItems2Functions();
var grpName = grp2Rate.Item1;
var grpRate = grp2Rate.Item2;
var useFxMapping = name2Op.ContainsKey(grpName);
var grpRates = useFxMapping
? name2Op[grpName](options)
: GetItemNames2Portions(grpName, options)
.ToDictionary(k => k.Item1, k => k.Item2);
foreach (var item in grpRates.Keys)
{
var p = GetNamedReceivableForItemAndGroup(item, grpName, options, grpRates[item] * grpRate);
itemsout.Add(p);
}
return(itemsout.ToArray());
}
public void TestAmericanFinAffidavit()
{
var options = AmericanDomusOpesOptions.RandomOpesOptions(
Domus.US.AmericanUtil.RandomAmericanFirstName(Gender.Female),
Domus.US.AmericanUtil.RandomAmericanLastName());
var income = AmericanIncome.RandomIncome(options);
options.SumTotal = income.Total.ToDouble();
var assets = AmericanAssets.RandomAssets(options);
var expenses = AmericanExpenses.RandomExpenses(options);
var allItems = income.ToData(KindsOfTextCase.Kabab);
foreach (var asset in assets.ToData(KindsOfTextCase.Kabab))
{
allItems.Add(asset.Key, asset.Value);
}
foreach (var expense in expenses.ToData(KindsOfTextCase.Kabab))
{
allItems.Add(expense.Key, expense.Value);
}
foreach (var key in allItems.Keys)
{
Console.WriteLine($"{key}, {allItems[key]}");
}
}
public void TestGetGroupNames2Portions()
{
var testInput = new AmericanDomusOpesOptions();
testInput.AddGivenDirectly("Real Property", 7800);
testInput.AddGivenDirectly("Securities", 1000);
testInput.SumTotal = 12000;
var testSubject = new AmericanAssets();
var testResult = testSubject.GetGroupNames2Portions(testInput);
Assert.IsNotNull(testResult);
Assert.AreNotEqual(0, testResult.Count);
var testResultSum = testResult.Select(i => i.Item2).Sum();
Assert.IsTrue(Math.Round(testResultSum) == 1.0D);
var testResult00 = testResult.FirstOrDefault(k => k.Item1 == "Real Property");
Assert.IsNotNull(testResult00);
var testResult01 = testResult.FirstOrDefault(k => k.Item1 == "Securities");
Assert.IsNotNull(testResult01);
foreach (var tr in testResult)
{
System.Diagnostics.Debug.WriteLine(tr);
}
Assert.AreEqual(Math.Round(7800.0D / 12000, 3), Math.Round(testResult00.Item2, 3));
Assert.AreEqual(Math.Round(1000.0D / 12000, 3), Math.Round(testResult01.Item2, 3));
}
/// <summary>
/// Factory method to get a list of group-name to group-rate using
/// the given <see cref="options"/>
/// </summary>
/// <param name="options"></param>
/// <returns>
/// A set of item names to some percent where the sum of all the names is 1 (i.e. 100%).
/// </returns>
protected internal virtual List <Tuple <string, double> > GetGroupNames2Portions(AmericanDomusOpesOptions options)
{
options = options ?? AmericanDomusOpesOptions.RandomOpesOptions();
var grpNames = GetGroupNames(DivisionName);
return(options.GetNames2Portions(grpNames.ToArray()));
}
public void TestGetItemNames2Portions()
{
var testInput = new AmericanDomusOpesOptions();
var grpName = "Institutional";
testInput.AddGivenDirectly("Partnerships", grpName, 7800);
testInput.AddGivenDirectly("Fellowships", grpName, 1000);
testInput.AddGivenDirectly("Annuity", grpName, 1000);
testInput.SumTotal = 15000;
var testSubject = new AmericanIncome();
var testResults =
testSubject.GetItemNames2Portions(grpName, testInput);
Assert.IsNotNull(testResults);
Assert.AreNotEqual(0, testResults.Count);
var testResultSum = testResults.Select(kv => kv.Item2).Sum();
System.Diagnostics.Debug.WriteLine(testResultSum);
Assert.IsTrue(Math.Round(testResultSum) == 1.0D);
//expect that when SumTotal is unassigned the ratios align exactly with assigned values
testInput = new AmericanDomusOpesOptions();
testInput.AddGivenDirectly("Partnerships", grpName, 7800);
testInput.AddGivenDirectly("Fellowships", grpName, 1000);
testInput.AddGivenDirectly("Annuity", grpName, 1000);
testSubject = new AmericanIncome();
testResults =
testSubject.GetItemNames2Portions(grpName, testInput);
Assert.IsNotNull(testResults);
Assert.AreNotEqual(0, testResults.Count);
testResultSum = testResults.Select(kv => kv.Item2).Sum();
System.Diagnostics.Debug.WriteLine(testResultSum);
var trWages = testResults.FirstOrDefault(kv => kv.Item1 == "Partnerships");
var trOt = testResults.FirstOrDefault(kv => kv.Item1 == "Fellowships");
var trBonus = testResults.FirstOrDefault(kv => kv.Item1 == "Annuity");
Assert.IsNotNull(trWages);
Assert.IsNotNull(trOt);
Assert.IsNotNull(trBonus);
Assert.AreEqual(0.796D, Math.Round(trWages.Item2, 3));
Assert.AreEqual(0.102D, Math.Round(trOt.Item2, 3));
Assert.AreEqual(0.102D, Math.Round(trBonus.Item2, 3));
foreach (var tr in testResults)
{
System.Diagnostics.Debug.WriteLine(tr);
}
}
public void TestGetClone()
{
var testInput = new AmericanDomusOpesOptions
{
Inception = DateTime.Today.AddYears(-1),
DueFrequency = new TimeSpan(1, 0, 0, 0),
Rate = RandPortions.DiminishingRate.Fast,
SumTotal = 88000,
IsVehiclePaidOff = true,
NumberOfCreditCards = 3,
NumberOfVehicles = 2,
IsRenting = true,
IsPayingChildSupport = true,
IsPayingSpousalSupport = true
};
testInput.AddPossibleZeroOuts("abc", "xyz");
testInput.ChildrenDobs.Add(DateTime.Today.AddYears(-2));
testInput.ChildrenDobs.Add(DateTime.Today.AddYears(-4));
testInput.AddGivenDirectly("name00", "group00", 9900);
testInput.AddGivenDirectly("name01", "group00", 1100);
var testResult = testInput.GetClone();
Assert.IsNotNull(testResult);
Assert.AreEqual(testInput.Inception, testResult.Inception);
Assert.AreEqual(testInput.DueFrequency, testResult.DueFrequency);
Assert.AreEqual(testInput.Rate, testResult.Rate);
Assert.AreEqual(testInput.SumTotal, testResult.SumTotal);
Assert.AreEqual(testInput.IsVehiclePaidOff, testResult.IsVehiclePaidOff);
Assert.AreEqual(testInput.NumberOfCreditCards, testResult.NumberOfCreditCards);
Assert.AreEqual(testInput.NumberOfVehicles, testResult.NumberOfVehicles);
Assert.AreEqual(testInput.IsRenting, testResult.IsRenting);
Assert.AreEqual(testInput.IsPayingChildSupport, testResult.IsPayingChildSupport);
Assert.AreEqual(testInput.IsPayingSpousalSupport, testResult.IsPayingSpousalSupport);
Assert.IsTrue(testResult.IsPayingChildSupport);
Assert.AreEqual(2, testResult.PossibleZeroOutCount);
Assert.IsNotNull(testResult.GetChildrenAges());
Assert.AreEqual(2, testResult.GetChildrenAges().Count);
Assert.IsTrue(testResult.AnyGivenDirectly());
Assert.AreEqual(2, testResult.GivenDirectlyCount);
Assert.IsNotNull(testResult.FactorOptions);
var testInputFr = testInput.FactorOptions;
var testResultFt = testResult.FactorOptions;
Assert.AreEqual(testInputFr.DateOfBirth, testResultFt.DateOfBirth);
Assert.AreEqual(testInputFr.EducationLevel, testResultFt.EducationLevel);
Assert.AreEqual(testInputFr.Gender, testResultFt.Gender);
Assert.AreEqual(testInputFr.MaritalStatus, testResultFt.MaritalStatus);
Assert.AreEqual(testInputFr.Race, testResultFt.Race);
Assert.AreEqual(testInputFr.Region, testResultFt.Region);
}
/// <summary>
/// While <see cref="GetItemsForRange(AmericanDomusOpesOptions)"/> deals with all the
/// items of this <see cref="DivisionName"/> this is concerned with one-item-at-a-time.
/// </summary>
/// <param name="itemName"></param>
/// <param name="grpName"></param>
/// <param name="options"></param>
/// <param name="rate"></param>
/// <returns></returns>
protected internal virtual NamedTradeline GetNamedReceivableForItemAndGroup(string itemName, string grpName, AmericanDomusOpesOptions options, double rate)
{
options = options ?? AmericanDomusOpesOptions.RandomOpesOptions();
var calcValueR = CalcValue((options.SumTotal ?? 0).ToPecuniam(), rate);
var p = NamedTradeline.RandomNamedTradelineWithHistoryToSum(itemName, grpName, calcValueR,
options.DueFrequency, options.Inception, options.Terminus);
return(p);
}
/// <summary>
/// Factory method to get a list of item-name to item-rate using
/// the given <see cref="options"/>
/// </summary>
/// <param name="groupName"></param>
/// <param name="options"></param>
/// <returns>
/// A set of item names to some percent where the sum of all the names is 1 (i.e. 100%).
/// </returns>
protected internal virtual List <Tuple <string, double> > GetItemNames2Portions(string groupName, AmericanDomusOpesOptions options)
{
options = options ?? AmericanDomusOpesOptions.RandomOpesOptions();
//get all the item names we are targeting
var itemNames = GetItemNames(DivisionName).Where(x =>
String.Equals(x.GetName(KindsOfNames.Group), groupName, StringComparison.OrdinalIgnoreCase)).ToArray();
return(options.GetNames2Portions(itemNames.Select(k => k.Name).ToArray()));
}
/// <summary>
/// The reusable\common parts of <see cref="RandomizeAllItems"/>
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
protected internal virtual NamedTradeline[] GetItemsForRange(AmericanDomusOpesOptions options)
{
options = options ?? AmericanDomusOpesOptions.RandomOpesOptions();
var itemsout = new List <NamedTradeline>();
var grp2Rates = GetGroupNames2Portions(options);
foreach (var grp in grp2Rates)
{
itemsout.AddRange(GetItemsForRange(grp, options));
}
return(itemsout.ToArray());
}
public void TestGetPaycheck()
{
var options = new AmericanDomusOpesOptions {
IsRenting = true
};
options.FactorOptions.Gender = Gender.Female;
options.FactorOptions.DateOfBirth = Etx.RandomAdultBirthDate();
var testResult = options.GetRandomYearlyIncome(null, 1.0.ToPecuniam());
Console.WriteLine(testResult);
Assert.IsNotNull(testResult);
Assert.IsTrue(testResult.Amount > 0.0M);
}
public void TestResolveItems()
{
var testOptions = new AmericanDomusOpesOptions {
SumTotal = 10000.0D
};
var testSubject = new AmericanExpenses();
testSubject.RandomizeAllItems(testOptions);
Assert.IsNotNull(testSubject.MyItems);
Assert.AreNotEqual(0, testSubject.MyItems.Count);
foreach (var item in testSubject.MyItems)
{
Console.WriteLine(item);
}
}
public void TestDeductionsRatioToIncome()
{
var testInput = new AmericanEmployment();
var annualIncome = 75000.ToPecuniam();
var options = new AmericanDomusOpesOptions
{
Inception = DateTime.Today.AddYears(-1),
SumTotal = annualIncome.ToDouble()
};
testInput.RandomizeAllItems(options);
//check input is good
Assert.IsNotNull(testInput.MyItems);
Assert.AreNotEqual(0, testInput.MyItems.Count);
var diff = Math.Abs(testInput.Total.ToDouble() - annualIncome.ToDouble());
Console.WriteLine(diff);
Assert.IsTrue(Math.Round(diff) == 0.0D);
var testSubject = new AmericanDeductions(testInput);
testSubject.RandomizeAllItems(null);
Assert.IsNotNull(testSubject.MyItems);
Assert.AreNotEqual(0, testSubject.MyItems.Count);
var totalDeductions = testSubject.Total;
Assert.AreNotEqual(0.0D.ToPecuniam(), totalDeductions);
//expect deductions as a negative number
Assert.IsTrue(totalDeductions.ToDouble() < 0.0D);
Console.WriteLine(totalDeductions);
var ratio = Math.Abs(Math.Round(((annualIncome + totalDeductions) / annualIncome).ToDouble(), 2));
Assert.IsTrue(ratio < 1.0);
Assert.IsTrue(ratio > 0.5);
Console.WriteLine(totalDeductions);
}
public void TestGetAtLeastOneVehicle()
{
var countOfTrue = 0D;
var total = 512;
for (var i = 0; i < total; i++)
{
var tr = AmericanDomusOpesOptions.GetAtLeastOneVehicle(UrbanCentric.City | UrbanCentric.Large);
if (tr)
{
countOfTrue += 1;
}
}
var testResult = Math.Round(countOfTrue / total, 3) * 100;
Assert.IsTrue(testResult < 39D);
Assert.IsTrue(testResult > 21D);
Console.WriteLine(testResult);
}
/// <summary> /// Gets all the items of the given Opes type as random values based on the /// options. /// </summary> /// <param name="options"></param> protected internal abstract void RandomizeAllItems(AmericanDomusOpesOptions options);
