/// <summary>
/// Returns State Withholding for Alabama, when provided with a non-negative value for Gross Wages, Federal Withholding and Dependent Allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="federalWithholding"></param>
/// <param name="filingStatus"></param>
/// <param name="dependentAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, decimal federalWithholding, FilingStatus filingStatus = FilingStatus.Single, int dependentAllowances = 0)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (federalWithholding < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(federalWithholding)} cannot be a negative number");
}
if (dependentAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(dependentAllowances)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
var annualWages = taxableWages;
taxableWages -= frequency.CalculateAnnualized(federalWithholding);
taxableWages -= GetStandardDeduction(filingStatus, annualWages);
taxableWages -= GetPersonalAllowance(filingStatus);
taxableWages -= GetDependentAllowance(annualWages, dependentAllowances);
var taxWithheld = GetTaxWithholding(filingStatus, taxableWages);
return(Math.Max(Decimal.Zero, frequency.CalculateDeannualized(taxWithheld)));
}
/// <summary>
/// Returns Indiana State Withholding when a non-negative value is given for gross wages, personal allowances and dependent allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="personalAllowances"></param>
/// <param name="dependentAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, int personalAllowances = 1, int dependentAllowances = 0)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (personalAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(personalAllowances)} cannot be a negative number");
}
if (dependentAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(dependentAllowances)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= GetPersonalAllowance(personalAllowances);
taxableWages -= GetDependentAllowance(dependentAllowances);
var taxWithheld = GetTaxWithholding(taxableWages);
return(Math.Max(0, frequency.CalculateDeannualized(taxWithheld)));
}
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, int exemptions = 0)
{
var annualized_wages = frequency.CalculateAnnualized(grossWages);
// G(P) - [$3,000 + (E1 x $930) + (E2 x $800)] = T
// Gross Pay for Period * Number of pay periods per year - (3000 + Personal+Dependent Exemptions x 930 + Age 65 and Over & Blind Exemptions x $800)
annualized_wages -= 3000; // Standard Deduction
annualized_wages -= (exemptions * 930); // Personal + Dependent Exemptions
decimal annualized_taxes = 0;
if (annualized_wages < 3000)
{
annualized_taxes = annualized_wages * 0.02m;
}
else if (annualized_wages < 5000)
{
annualized_taxes = 60 + (annualized_wages - 3000) * 0.03m;
}
else if (annualized_wages < 17000)
{
annualized_taxes = 120 + (annualized_wages - 5000) * 0.05m;
}
else
{
annualized_taxes = 720 + (annualized_wages - 17000) * 0.0575m;
}
return(frequency.CalculateDeannualized(annualized_taxes));
}
/// <summary>
/// Returns Hawaii State Withholding when provided with a non-negative value for Gross Wages and Allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="allowances"></param>
/// <param name="filingStatus"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, int allowances = 0, FilingStatus filingStatus = FilingStatus.Single)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (allowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(allowances)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= GetAllowances(allowances);
if (taxableWages <= 0)
{
return(0);
}
var selected_row = getTaxRateRow(taxableWages, filingStatus);
var wageWithheld = selected_row.TaxBase + ((taxableWages - selected_row.Floor) * selected_row.Rate);
return(frequency.CalculateDeannualized(Math.Max(0, wageWithheld)));
}
/// <summary>
/// Returns Lousiana State Withholding when given a non-negative value for Gross Wages, Personal Exemptions, and Dependents.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="filingStatus"></param>
/// <param name="personalExemptions"></param>
/// <param name="dependents"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus filingStatus, int personalExemptions = 0, int dependents = 0)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (personalExemptions < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(personalExemptions)} cannot be a negative number");
}
if (dependents < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(dependents)} cannot be a negative number");
}
var TaxableWages = frequency.CalculateAnnualized(grossWages);
var rate = GetRate(filingStatus, personalExemptions);
var deductions = GetDeductions(rate, personalExemptions, dependents);
var withholding = Math.Max(0, GetWithholding(rate, TaxableWages, deductions));
return(frequency.CalculateDeannualized(withholding));
}
/// <summary>
/// Returns Colorado State Withholding when given a non-negative value for Gross Wages and Personal Allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="filingStatus"></param>
/// <param name="personalAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus filingStatus, int personalAllowances)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (personalAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(personalAllowances)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= GetPersonalAllowance(personalAllowances);
if (taxableWages <= 0)
{
return(0);
}
var taxRate = GetTaxWithholding(filingStatus, taxableWages);
var taxWithheld = taxRate.TaxBase + ((taxableWages - taxRate.StartingAmount) * taxRate.TaxRate);
return(frequency.CalculateDeannualized(Math.Max(0, taxWithheld)).Round(decimals: 0));
}
/// <summary>
/// Returns Arkansas State Withholding when given a non-negative value for Gross Wages and Exemptions.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="exemptions"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, int exemptions = 0)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (exemptions < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(exemptions)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= StandardDeductionValue;
if (taxableWages < roundingValue)
{
taxableWages = applyMidpoint(taxableWages);
}
if (taxableWages <= 0)
{
return(0);
}
var withholdingTable = getBracket(taxableWages);
taxableWages = (withholdingTable.Percentage * taxableWages) - withholdingTable.FlatAmount;
taxableWages -= getExemptions(taxableWages, exemptions);
return(Math.Max(Decimal.Zero, frequency.CalculateDeannualized(taxableWages)));
}
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus filingStatus = FilingStatus.Single, int personalAllowances = 1, int dependentAllowances = 0)
{
var taxableWages = frequency.CalculateAnnualized(grossWages);
// Note: Tax exemptions should be handled before we get to this call
// if (FilingStatus.Exempt == filingStatus) return Decimal.Zero;
//Use these instructions to calculate employee withholding using the percentage method.
//(1) Subtract the applicable standard deduction as indicated in column(1) - (3) of Table E.
taxableWages -= GetStandardDeduction(filingStatus);
//(2) Subtract from the amount arrived at in (1) the appropriate amount of personal allowance as set out in column(4) – (6) of Table E.
taxableWages -= GetPersonalAllowance(filingStatus, personalAllowances);
//(3) If employees claim dependents other than themselves and/or their spouses, subtract from the amount arrived at in (2) the appropriate dependent amount as set out in column(7) of Table E.
taxableWages -= GetDependentAllowance(filingStatus, dependentAllowances);
//(4) Determine the amount of tax to be withheld from the applicable payroll line in Tables F, G, or H.
var selected_row = GetTaxWithholding(filingStatus, taxableWages);
// Calculate the withholding from the percentages
var taxWithheld = selected_row.TaxBase + ((taxableWages - selected_row.StartingAmount) * selected_row.TaxRate);
//(5) If zero exemption is claimed, subtract the standard deduction only.
return(frequency.CalculateDeannualized(taxWithheld));
}
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus filingStatus, int exemptions = 0)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (exemptions < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(exemptions)} cannot be a negative number");
}
var annualized_wages = frequency.CalculateAnnualized(grossWages);
var taxedWages = annualized_wages * TaxRateA;
var allowances = GetAllowances(filingStatus, exemptions);
annualized_wages -= GetStandardDeduction(filingStatus);
annualized_wages = annualized_wages * TaxRateB;
var deduction = allowances - annualized_wages;
var taxWithheld = taxedWages - deduction;
return(frequency.CalculateDeannualized(Math.Max(taxWithheld, 0)));
}
/// <summary>
/// Returns Maine State Withholding when given a non-negative value for Gross Wages and Withholding Allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="filingStatus"></param>
/// <param name="withholdingAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus filingStatus = FilingStatus.Single, int withholdingAllowances = 1)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (withholdingAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(withholdingAllowances)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
var annualWages = taxableWages;
taxableWages -= GetWitholdingAllowance(withholdingAllowances);
taxableWages -= GetStandardDeduction(filingStatus, annualWages);
if (taxableWages > 0)
{
var selected_row = GetTaxWithholding(filingStatus, taxableWages);
var taxWithheld = selected_row.TaxBase + ((taxableWages - selected_row.StartingAmount) * selected_row.TaxRate);
return(frequency.CalculateDeannualized(taxWithheld));
}
else
{
return(0);
}
}
/// <summary>
/// Returns Oregon State Withholding when given a non-negative value for Federal Withholding, Gross Wages and Personal Allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="federalWithholding"></param>
/// <param name="filingStatus"></param>
/// <param name="personalAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, decimal federalWithholding, FilingStatus filingStatus = FilingStatus.Single, int personalAllowances = 1)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (federalWithholding < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(federalWithholding)} cannot be a negative number");
}
if (personalAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(personalAllowances)} cannot be a negative number");
}
var annualWages = frequency.CalculateAnnualized(grossWages);
var taxableWages = annualWages;
taxableWages -= Math.Min(GetFederalLimit(filingStatus, annualWages), federalWithholding);
taxableWages -= GetStandardDeduction(filingStatus, personalAllowances, annualWages);
if (taxableWages <= 0)
{
return(0);
}
var selected_row = GetTaxWithholding(filingStatus, personalAllowances, annualWages);
taxableWages = selected_row.TaxBase + ((taxableWages - selected_row.ExcessLimit) * selected_row.TaxRate);
var taxWithheld = taxableWages - GetPersonalAllowance(filingStatus, personalAllowances, annualWages);
return(frequency.CalculateDeannualized(Math.Max(0, taxWithheld)).Round(decimals: 0));
}
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus status = FilingStatus.Two_Earnings, int exemptions = 0)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (exemptions < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(exemptions)} cannot be a negative number");
}
var annualized_wages = frequency.CalculateAnnualized(grossWages);
annualized_wages -= (exemptions * ExemptionValue);
var bracket =
Brackets
.Where(_ => _.Status == status)
.Where(_ => _.Floor < annualized_wages)
.Where(_ => _.Ceiling >= annualized_wages)
.Single();
var annualized_withholding = bracket.FlatAmount + bracket.Percentage * (annualized_wages - bracket.Floor);
// Round to the nearest dollar
return(frequency.CalculateDeannualized(annualized_withholding).Round(decimals: 0));
}
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, int basicAllowances = 0, int additionalAllowances = 0)
{
var annualized_wages = frequency.CalculateAnnualized(grossWages);
//Step 1 Determine the wages paid for the payroll period.
//Step 2 Figure your employee’s exemptions using the allowances claimed on Form IL-W - 4.
//a Multiply the number of allowances your employee claimed on Form IL - W - 4, Line 1, by $2,175.
annualized_wages -= (basicAllowances * 2175);
//b Multiply the number of allowances your employee claimed on Form IL - W - 4, Line 2, by $1,000.
annualized_wages -= (additionalAllowances * 1000);
//c Add your answers from Step 2a and Step 2b.
//d Divide the result of Step 2c by the number of pay periods from the table. The result is your employee’s exemptions.
//Step 3 Subtract the exemptions from the wages paid.The result is the taxable amount.
//Step 4 Multiply the taxable amount by 3.75 percent(.0375).You must withhold this amount.
//Step 5 Add any additional amount from Form IL-W - 4, Line 3.This is the total amount you withhold.
// Note, we handle additional withholding requested on the processing side
var annualized_taxes = annualized_wages * 0.0375m;
return(frequency.CalculateDeannualized(annualized_taxes));
}
/// <summary>
/// Returns Idaho State Withholding when given a non-negative value for gross wages and personal allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="filingStatus"></param>
/// <param name="personalAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus filingStatus = FilingStatus.Single, int personalAllowances = 1)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (personalAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(personalAllowances)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= GetPersonalAllowance(personalAllowances);
if (taxableWages <= 0)
{
return(0);
}
var selected_row = GetTaxWithholding(filingStatus, taxableWages);
var taxWithheld = Math.Round(selected_row.TaxBase + ((taxableWages - selected_row.StartingAmount) * selected_row.TaxRate), MidpointRounding.AwayFromZero);
return(Math.Round(frequency.CalculateDeannualized(taxWithheld), MidpointRounding.AwayFromZero));
}
/// <summary>
/// Returns the State Withholding for Iowa when provided with a non-negative value for Gross Wages, Exemptions and Federal Withholding.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="FedWithholding"></param>
/// <param name="exemptions"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, Decimal FedWithholding = 0, int exemptions = 0)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (exemptions < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(exemptions)} cannot be a negative number");
}
if (FedWithholding < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(FedWithholding)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= frequency.CalculateAnnualized(FedWithholding);
taxableWages -= GetStandardDeduction(exemptions);
var withheldWages = FindWithholding(taxableWages);
withheldWages -= GetAllowances(exemptions);
return(Math.Max(0, frequency.CalculateDeannualized(withheldWages)));
}
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, WithholdingCode employeeCode, int exemptions = 1)
{
// Additional/Reduced Withholding handled outside of this calculation
if (employeeCode == WithholdingCode.E)
{
return(0);
}
var annualizedSalary = frequency.CalculateAnnualized(grossWages);
var taxableWages = annualizedSalary;
taxableWages -= GetExemptionAmount(taxableWages, employeeCode, exemptions);
if (taxableWages > 0)
{
var withHolding = GetTaxWithholding(employeeCode, taxableWages);
taxableWages = withHolding.TaxBase + ((taxableWages - withHolding.StartingAmount) * withHolding.TaxRate);
taxableWages += CheckAddBack(employeeCode, annualizedSalary);
taxableWages += GetTaxRecapture(employeeCode, annualizedSalary);
var taxWithheld = taxableWages * (1 - GetPersonalTaxCredits(employeeCode, annualizedSalary));
taxWithheld = frequency.CalculateDeannualized(taxWithheld);
//taxWithheld += additionalWithholding;
//taxWithheld -= reducedWithholding;
return(Math.Max(taxWithheld, 0));
}
else
{
//taxableWages += additionalWithholding;
//taxableWages -= reducedWithholding;
return(Math.Max(taxableWages, 0));
}
}
/// <summary>
/// Returns Missouri Withholding when given a non-negative value for Gross Wages, Federal Withholding and Personal Allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="filingStatus"></param>
/// <param name="federalWithholding"></param>
/// <param name="personalAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, FilingStatus filingStatus, Decimal federalWithholding, int personalAllowances)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (personalAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(personalAllowances)} cannot be a negative number");
}
if (federalWithholding < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(federalWithholding)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
var fedWithholding = frequency.CalculateAnnualized(federalWithholding);
taxableWages -= GetStandardDeduction(filingStatus);
taxableWages -= GetPersonalAllowance(filingStatus, personalAllowances);
taxableWages -= GetFederalWithholding(filingStatus, federalWithholding);
var taxWithheld = GetTaxWithholding(filingStatus, taxableWages);
return(frequency.CalculateDeannualized(Math.Max(0, taxWithheld)).Round(decimals: 0));
}
/// <summary>
/// Returns Ohio State Withholding when given a non-negative number for gross wages and exemptions.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="exemptions"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, int exemptions)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (exemptions < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(exemptions)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= GetExemptions(exemptions);
if (taxableWages <= 0)
{
return(0);
}
var selected_row = GetTaxWithholding(taxableWages);
taxableWages = (selected_row.TaxBase + ((taxableWages - selected_row.StartingAmount) * selected_row.TaxRate));
var taxWithheld = frequency.CalculateDeannualized(Math.Max(0, taxableWages)) * TaxRate;
return(taxWithheld.Round(decimals: 2));
}
/// <summary>
/// Returns Rhode Island State Withholding when given a non-negative values for Gross Wages and Personal Allowances.
/// </summary>
/// <param name="grossWages"></param>
/// <param name="frequency"></param>
/// <param name="personalAllowances"></param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when Negative Values entered.</exception>
/// <returns></returns>
public virtual Decimal Calculate(Decimal grossWages, PayrollFrequency frequency, int personalAllowances = 1)
{
if (grossWages < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(grossWages)} cannot be a negative number");
}
if (personalAllowances < Decimal.Zero)
{
throw new ArgumentOutOfRangeException($"{nameof(personalAllowances)} cannot be a negative number");
}
var taxableWages = frequency.CalculateAnnualized(grossWages);
taxableWages -= GetPersonalAllowance(taxableWages, personalAllowances);
if (taxableWages <= 0)
{
return(0);
}
var selected_row = GetTaxWithholding(taxableWages);
var taxWithheld = selected_row.TaxBase + ((taxableWages - selected_row.StartingAmount) * selected_row.TaxRate);
return(frequency.CalculateDeannualized(taxWithheld));
}
public void Utah_2017_Checks_And_Balances(decimal grossWages, PayrollFrequency freq, FilingStatus filingStatus, int personalAllowances, decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.UT, year: 2017) as Utah.TaxTable;
var result = table.Calculate(grossWages, freq, filingStatus, personalAllowances);
Assert.AreEqual(expected, result);
}
public void Missouri_2017_Checks_And_Balances(PayrollFrequency frequency, Decimal grossWages, FilingStatus filingStatus, decimal federalWithholding, int allowances, Decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.MO, year: 2017) as Missouri.TaxTable2017;
var result = table.Calculate(grossWages, frequency, filingStatus, federalWithholding, allowances);
Assert.AreEqual(expected, result);
}
public void DEChecks_And_Balances(PayrollFrequency frequency, Decimal grossWages, Delaware.FilingStatus filingStatus, int allowances, Decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.DE, year: 2017) as Delaware.TaxTable;
var result = table.Calculate(grossWages, frequency, filingStatus, allowances);
Assert.AreEqual(expected, result);
}
public void AR_2017_Checks_And_Balances(decimal grossWages, PayrollFrequency frequency, int exemptions, decimal expected)
{
var taxTable = TaxTables.GetForState(StateOrProvince.AR, year: 2017) as Arkansas.TaxTable;
var result = taxTable.Calculate(grossWages, frequency, exemptions);
Assert.AreEqual(expected, result);
}
public void Checks_And_Balances(PayrollFrequency frequency, Decimal grossWages, int basicAllowances, int additionalAllowances, Decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.IL, year: 2016) as Illinois.TaxTable;
var result = table.Calculate(grossWages, frequency, basicAllowances, additionalAllowances);
Assert.AreEqual(expected, result);
}
public void Checks_And_Balances(decimal grossWages, PayrollFrequency freq, FilingStatus status, int personalAllowances, int dependentAllowances, decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.GA, year: 2016) as Georgia.TaxTable;
var result = table.Calculate(grossWages, freq, status, personalAllowances, dependentAllowances);
Assert.AreEqual(expected, result);
}
public void Ohio_2017_TaxTable(decimal grossWages, PayrollFrequency freq, int exemptions, decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.OH, year: 2017) as Ohio.TaxTable2017;
var result = table.Calculate(grossWages, freq, exemptions);
Assert.AreEqual(expected, result);
}
public void California_2017_Checks_And_Balances(PayrollFrequency frequency, Decimal grossWages, FilingStatus status, int allowances, int deductions, Decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.CA, year: 2017) as California.TaxTable2017;
var result = table.Calculate(grossWages, frequency, status, allowances, deductions);
Assert.AreEqual(expected, result);
}
public void Oregon_2017_Checks_And_Balances(decimal grossWages, PayrollFrequency freq, decimal federalWithholding, FilingStatus filingStatus, int personalAllowances, decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.OR, year: 2017) as Oregon.TaxTable2017;
var result = table.Calculate(grossWages, freq, federalWithholding, filingStatus, personalAllowances);
Assert.AreEqual(expected, result);
}
public void NewYorkTaxTable2017(decimal grossWages, PayrollFrequency freq, Region region, FilingStatus status, int personalAllowances, decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.NY, year: 2017) as NewYork.TaxTable;
var result = table.Calculate(grossWages, freq, region, status, personalAllowances);
Assert.AreEqual(expected, result);
}
public void Kentucky_2017_Checks_And_Balances(decimal grossWages, PayrollFrequency freq, int exemptions, decimal expected)
{
var table = TaxTables.GetForState(StateOrProvince.KY, year: 2017) as Kentucky.TaxTable2017;
var result = table.Calculate(grossWages, freq, exemptions);
Assert.AreEqual(expected, result);
}
