diff --git a/tampermonkey.js b/tampermonkey.js index 33747ae..078ca10 100644 --- a/tampermonkey.js +++ b/tampermonkey.js @@ -344,21 +344,144 @@ function renderOption(value, selectedValue, displayValue) { return optionHtml; } -function getCapPresidenceOptions(selectedAction) { + +const Presidence = Object.freeze({ + General: "general", + Row: "row", + Highest: "highest", + Lowest: "lowest" +}) + +const AppliesTo = Object.freeze({ + All: "all", + None: "none", + Capped: "capped", + Uncapped: "uncapped" +}) + +const Oversight = Object.freeze({ + Win: "win", + Tie: "tie", + Watch: "watch", + Ignore: "ignore" +}) + +const Capsource = Object.freeze({ + Row: "row", + General: "general" +}) + +const CapTrigger = Object.freeze({ + None: "None", + General: "General", + Row: "Row" +}) + +function getTrueCap(isGeneralCapEnabled, isRowCapIsEnabled, presidenceValue, generalCapValue, rowCapValue){ + + //Our response object + function trueCap(trigger, value) { + let response = {}; + response.trigger = trigger; + response.value = value; + return response; + } + + trueCap.trigger = CapTrigger.None; //Used to identify which cap the trueCap value was derived from. + trueCap.value = null; //The actual calculated true cap + + //Do some error handling to start off + if(isGeneralCapEnabled == true && generalCapValue == null) { + if(verboseLevel >= 1) { + console.warn("GeneralCap is enabled but the GeneralCapValue is not set - Acting as if GeneralCap was not enabled."); + } + isGeneralCapEnabled = false; + } + + if(isRowCapIsEnabled == true && rowCapValue == null) { + if(verboseLevel >= 1) { + console.warn("RowCap is enabled but the RowCapValue is not set - Acting as if RowCap was not enabled."); + } + isRowCapIsEnabled = false; + } + + //Now our actual logic begins + if(isGeneralCapEnabled == false && isRowCapIsEnabled == false) { + return trueCap(CapTrigger.None,null); //No cap available to return + } + + + if(isRowCapIsEnabled == true && rowCapValue == null) { + //console.warn("RowCap is enabled but the RowCapValue is not set"); + return trueCap(CapTrigger.None,null); //No cap available to return + } + + if(isGeneralCapEnabled == true) { + switch (presidenceValue) { + case Presidence.General: + //General wins + return trueCap(CapTrigger.General, generalCapValue); + + + case Presidence.Row: + if(isRowCapIsEnabled == true) { + //Row wins + return trueCap(CapTrigger.Row, rowCapValue); + } + return trueCap(CapTrigger.General, generalCapValue); + + case Presidence.Highest: + if(isRowCapIsEnabled == true) { + //Figure out which is higher + if(rowCapValue > generalCapValue) { + //Row wins + return trueCap(CapTrigger.Row, rowCapValue); + } + } + return trueCap(CapTrigger.General, generalCapValue);; + + case Presidence.Lowest: + if(isRowCapIsEnabled == true) { + if(rowCapValue < generalCapValue) { + //Row wins + return trueCap(CapTrigger.Row, rowCapValue); + } + } + return trueCap(CapTrigger.General, generalCapValue);; + + default: + return trueCap(CapTrigger.General, generalCapValue);; + } + + return trueCap(CapTrigger.General, generalCapValue);; + } + + //If we made it here then generalCap is not enabled but the row cap may still be enabled + if(isRowCapIsEnabled == true) { + return trueCap(CapTrigger.Row, rowCapValue); + } + + //We should never get here + return trueCap(CapTrigger.None, null); +} + + + +function getCapPresidenceOptions(selectedOption) { var optionsHtml = ""; - optionsHtml += renderOption("row", selectedAction, "Row Cap"); - optionsHtml += renderOption("general", selectedAction, "General Cap"); - optionsHtml += renderOption("highest", selectedAction, "Highest Cap"); - optionsHtml += renderOption("lowest", selectedAction, "Lowest Cap"); + optionsHtml += renderOption(Presidence.Row, selectedOption, "Row Cap"); + optionsHtml += renderOption(Presidence.General, selectedOption, "General Cap"); + optionsHtml += renderOption(Presidence.Highest, selectedOption, "Highest Cap"); + optionsHtml += renderOption(Presidence.Lowest, selectedOption, "Lowest Cap"); return optionsHtml; } -function getOversightOptions(countyId, selectedAction) { +function getOversightOptions(countyId, selectedOption) { var optionsHtml = ""; - optionsHtml += renderOption("win", selectedAction); - optionsHtml += renderOption("tie", selectedAction); - optionsHtml += renderOption("watch",selectedAction); - optionsHtml += renderOption("ignore",selectedAction); + optionsHtml += renderOption(Oversight.Win, selectedOption); + optionsHtml += renderOption(Oversight.Tie, selectedOption); + optionsHtml += renderOption(Oversight.Watch, selectedOption); + optionsHtml += renderOption(Oversight.Ignore, selectedOption); return optionsHtml; } @@ -378,7 +501,7 @@ function upsertOversight(countyOversightJson) { function convertToOversightJson(countyInfoJson, action, isBidCapEnabled){ const countyInfo = { - "id":countyInfoJson.id, + "id": countyInfoJson.id, "bidCap": countyInfoJson.bidCap, "isBidCapEnabled": isBidCapEnabled, "action": action @@ -403,21 +526,6 @@ function getBidCapReasonIcon(reason) { } function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap, generalCapIsEnabled, generalCap, capPresidence, applyPresidenceTo) { - const Presidence_General = "general"; - const Presidence_Row = "row"; - const Presidence_Highest = "highest"; - const Presidence_Lowest = "lowest"; - const AppliesTo_All = "all"; - const AppliesTo_None = "none"; - const AppliesTo_Capped = "capped"; - const AppliesTo_Uncapped = "uncapped"; - const Oversight_Win = "win"; - const Oversight_Tie = "tie"; - const Oversight_Watch = "watch"; - const Oversight_Ignore = "ignore"; - const Capsource_Row = "row"; - const Capsource_General = "general"; - let tieBidNum = number(tieBid); let winBidNum = number(tieBid) + 25; let generalCapNum = number(generalCap); @@ -434,15 +542,15 @@ function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap //WIP - LOTS of rules here - these are just the beginning. if(generalCapIsEnabled) { - if(capPresidence == Presidence_General) { - if(applyPresidenceTo == AppliesTo_All) { + if(capPresidence == Presidence.General) { + if(applyPresidenceTo == AppliesTo.All) { results.shouldApplyCap = false; - results.capSource = Capsource_General; + results.capSource = Capsource.General; results.trueCap = generalCapNum; switch(oversightAction) { - case Oversight_Win: + case Oversight.Win: if(winBidNum > generalCapNum) { results.shouldApplyCap = true; results.reason = 1; @@ -454,7 +562,7 @@ function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap results.myBid = myBidNum; break; - case Oversight_Tie: + case Oversight.Tie: if(tieBidNum > generalCapNum) { results.shouldApplyCap = true; results.reason = 3; @@ -466,11 +574,11 @@ function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap results.myBid = myBidNum; break; - case Oversight_Watch: + case Oversight.Watch: results.reason = 5; break; - case Oversight_Ignore: + case Oversight.Ignore: results.reason = 6; break; @@ -479,24 +587,24 @@ function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap } return results; } - else if(applyPresidenceTo == AppliesTo_None){ + else if(applyPresidenceTo == AppliesTo.None){ } - else if(applyPresidenceTo == AppliesTo_Capped){ + else if(applyPresidenceTo == AppliesTo.Capped){ } - else if(applyPresidenceTo == AppliesTo_Uncapped){ + else if(applyPresidenceTo == AppliesTo.Uncapped){ } return results; } - else if(capPresidence == Presidence_Row) { + else if(capPresidence == Presidence.Row) { return results; } - else if(capPresidence == Presidence_Highest){ + else if(capPresidence == Presidence.Highest){ return results; } - else if(capPresidence == Presidence_Lowest){ + else if(capPresidence == Presidence.Lowest){ return results; } } @@ -504,12 +612,12 @@ function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap //This means rowCaps are the winners if they are enabled. if(rowCapIsEnabled) { switch(oversightAction) { - case Oversight_Win: + case Oversight.Win: if(winBidNum > rowCapNum) { results.shouldApplyCap = true; results.reason = 101; results.trueCap = rowCapNum; - results.capSource = Capsource_Row; + results.capSource = Capsource.Row; results.myBid = rowCapNum; return results; } @@ -517,16 +625,16 @@ function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap results.shouldApplyCap = false; results.reason = 102; results.trueCap = rowCapNum; - results.capSource = Capsource_Row; + results.capSource = Capsource.Row; results.myBid = myBidNum; break; - case Oversight_Tie: + case Oversight.Tie: if(tieBidNum > rowCapNum) { results.shouldApplyCap = true; results.reason = 103; results.trueCap = rowCapNum; - results.capSource = Capsource_Row; + results.capSource = Capsource.Row; results.myBid = rowCapNum; return results; } @@ -534,23 +642,23 @@ function getBidCapReason(tieBid, myBid, oversightAction, rowCapIsEnabled, rowCap results.shouldApplyCap = false; results.reason = 104; results.trueCap = rowCapNum; - results.capSource = Capsource_Row; + results.capSource = Capsource.Row; results.myBid = myBidNum; break; - case Oversight_Watch: + case Oversight.Watch: results.shouldApplyCap = false; results.reason = 105; results.trueCap = null; - results.capSource = Capsource_Row; + results.capSource = Capsource.Row; results.myBid = myBidNum; break; - case Oversight_Ignore: + case Oversight.Ignore: results.shouldApplyCap = false; results.reason = 106; results.trueCap = null; - results.capSource = Capsource_Row; + results.capSource = Capsource.Row; results.myBid = myBidNum; break; default: @@ -600,19 +708,19 @@ function injectOversight(countyId, action) { //Begin TODO: move this code block elsewhere IT IS WIP const settingsCapPresidence = alwaysWinSettings.capPresidence; - const settings_Presidence_RowCap = (settingsCapPresidence == "row"); - const settings_Presidence_GeneralCap = (settingsCapPresidence == "generl"); - const settings_Presidence_HighestCap = (settingsCapPresidence == "highest"); - const settings_Presidence_LowestCap = (settingsCapPresidence == "lowest"); - - const settingsGeneralCapAppliesTo = "capped" //[n,a,c,u] - const settings_GeneralCapAppliesTo_None = (settingsGeneralCapAppliesTo == "none")//None of the - const settings_GeneralCapAppliesTo_All = (settingsGeneralCapAppliesTo == "all")//All - const settings_GeneralCapAppliesTo_Capped = (settingsGeneralCapAppliesTo == "capped")//Capped Only - const settings_GeneralCapAppliesTo_Uncapped = (settingsGeneralCapAppliesTo == "uncapped")//UnCapped Only - - const rowCapControlsShouldBeVisible = (action == "win" || action == "tie"); //TODO write logic to determine if the enable Bidcap checkbox and words should be visible - const rowCapCheckboxShouldBeVisible = (action == "win" || action == "tie"); //TODO: write logic + const settings_Presidence_RowCap = (settingsCapPresidence == Presidence.Row); + const settings_Presidence_GeneralCap = (settingsCapPresidence == Presidence.General); + const settings_Presidence_HighestCap = (settingsCapPresidence == Presidence.Highest); + const settings_Presidence_LowestCap = (settingsCapPresidence == Presidence.Lowest); + + const settingsGeneralCapAppliesTo = Presidence.General + const settings_GeneralCapAppliesTo_None = (settingsGeneralCapAppliesTo == AppliesTo.None)//None of the + const settings_GeneralCapAppliesTo_All = (settingsGeneralCapAppliesTo == AppliesTo.All)//All + const settings_GeneralCapAppliesTo_Capped = (settingsGeneralCapAppliesTo == AppliesTo.Capped)//Capped Only + const settings_GeneralCapAppliesTo_Uncapped = (settingsGeneralCapAppliesTo == AppliesTo_Uncapped)//UnCapped Only + + const rowCapControlsShouldBeVisible = (action == Oversight.Win || action == Oversight.Tie); //TODO write logic to determine if the enable Bidcap checkbox and words should be visible + const rowCapCheckboxShouldBeVisible = (action == Oversight.Win || action == Oversight.Tie); //TODO: write logic const rowCapCheckboxShouldBeDisabled = false; //TODO: write logic const rowCapCheckboxShouldBeChecked = false; //TODO: write logic @@ -620,7 +728,8 @@ function injectOversight(countyId, action) { const rowCapInputIsBeingOverridden = settings_Presidence_GeneralCap; //TODO: write logic const rowCapInputShouldBeDisabled = (rowCapInputIsBeingOverridden || !rowCapCheckboxShouldBeChecked); //TODO: write logic - const trueCap = alwaysWinSettings.generalCap; //countyJson.bidCap; //TODO actually calcuate instead of reading from settings + const trueCap = getTrueCap(isGeneralCapEnabled,) alwaysWinSettings.generalCap; //countyJson.bidCap; //TODO actually calcuate instead of reading from settings + //const trueCap = getTrueCap(isGeneralCapEnabled,isRowCapIsEnabled,presidenceValue,generalCapNum,rowCapNum); //TODO: Uncomment this line once I get the params right. const capIsCurrentlyBeingAppliedToBid = countyJson.bid > Number(trueCap); //End TODO @@ -745,16 +854,16 @@ jQuery(window).on('load',function() { const countyInfoJson = getCountyInfo(currentEntity.id); //console.log(currentEntity); switch (currentEntity.action) { - case "win": + case Oversight.Win: winCounty(countyInfoJson,true); break; - case "tie": + case Oversight.Tie: tieCounty(countyInfoJson,true); break; - case "watch": + case Oversight.Watch: watchCounty(countyInfoJson,false); break; - case "ignore": + case Oversight.Ignore: ignoreCounty(countyInfoJson, false); break; default: diff --git a/test.js b/test.js index 19596e1..718c372 100644 --- a/test.js +++ b/test.js @@ -1,4 +1,6 @@ -//Setup some enum's +///////////////////////////////////////////////////////////////// +////////BEGIN THIS CODE LIVES IN TAMPERMONKEY.JS = THIS IS A COPY + const Presidence = Object.freeze({ General: "general", Row: "row", @@ -25,6 +27,105 @@ const Capsource = Object.freeze({ General: "general" }) +const CapTrigger = Object.freeze({ + None: "None", + General: "General", + Row: "Row" +}) + +function getTrueCap(isGeneralCapEnabled, isRowCapIsEnabled, presidenceValue, generalCapValue, rowCapValue){ + + //Our response object + function trueCap(trigger, value) { + let response = {}; + response.trigger = trigger; + response.value = value; + return response; + } + + trueCap.trigger = CapTrigger.None; //Used to identify which cap the trueCap value was derived from. + trueCap.value = null; //The actual calculated true cap + + //Do some error handling to start off + if(isGeneralCapEnabled == true && generalCapValue == null) { + if(verboseLevel >= 1) { + console.warn("GeneralCap is enabled but the GeneralCapValue is not set - Acting as if GeneralCap was not enabled."); + } + isGeneralCapEnabled = false; + } + + if(isRowCapIsEnabled == true && rowCapValue == null) { + if(verboseLevel >= 1) { + console.warn("RowCap is enabled but the RowCapValue is not set - Acting as if RowCap was not enabled."); + } + isRowCapIsEnabled = false; + } + + //Now our actual logic begins + if(isGeneralCapEnabled == false && isRowCapIsEnabled == false) { + return trueCap(CapTrigger.None,null); //No cap available to return + } + + + if(isRowCapIsEnabled == true && rowCapValue == null) { + //console.warn("RowCap is enabled but the RowCapValue is not set"); + return trueCap(CapTrigger.None,null); //No cap available to return + } + + if(isGeneralCapEnabled == true) { + switch (presidenceValue) { + case Presidence.General: + //General wins + return trueCap(CapTrigger.General, generalCapValue); + + + case Presidence.Row: + if(isRowCapIsEnabled == true) { + //Row wins + return trueCap(CapTrigger.Row, rowCapValue); + } + return trueCap(CapTrigger.General, generalCapValue); + + case Presidence.Highest: + if(isRowCapIsEnabled == true) { + //Figure out which is higher + if(rowCapValue > generalCapValue) { + //Row wins + return trueCap(CapTrigger.Row, rowCapValue); + } + } + return trueCap(CapTrigger.General, generalCapValue);; + + case Presidence.Lowest: + if(isRowCapIsEnabled == true) { + if(rowCapValue < generalCapValue) { + //Row wins + return trueCap(CapTrigger.Row, rowCapValue); + } + } + return trueCap(CapTrigger.General, generalCapValue);; + + default: + return trueCap(CapTrigger.General, generalCapValue);; + } + + return trueCap(CapTrigger.General, generalCapValue);; + } + + //If we made it here then generalCap is not enabled but the row cap may still be enabled + if(isRowCapIsEnabled == true) { + return trueCap(CapTrigger.Row, rowCapValue); + } + + //We should never get here + return trueCap(CapTrigger.None, null); +} +////////END THIS CODE LIVES IN TAMPERMONKEY.JS = THIS IS A COPY +/////////////////////////////////////////////////////////////// + + +//Setup some enum's + const TestResult = Object.freeze({ Pass: "Pass", Fail: "Fail" @@ -1138,89 +1239,24 @@ function getExpectedOutcomes_where_only_a_GeneralCap_can_be_triggered(){ return expectedOutcomes; } -function getTrueCap(isGeneralCapEnabled, isRowCapIsEnabled, presidenceValue, generalCapValue, rowCapValue){ - //Do some error handling to start off - if(isGeneralCapEnabled == true && generalCapValue == null) { - if(verboseLevel >= 1) { - console.warn("GeneralCap is enabled but the GeneralCapValue is not set - Acting as if GeneralCap was not enabled."); - } - isGeneralCapEnabled = false; - } +function getTrueCapAsTestResult(isGeneralCapEnabled, isRowCapIsEnabled, presidenceValue, generalCapValue, rowCapValue){ + //This is a helper method to help make testing results a bit easier. + const trueCap = getTrueCap(isGeneralCapEnabled, isRowCapIsEnabled, presidenceValue, generalCapValue, rowCapValue) + return [trueCap.trigger, trueCap.value]; +} - if(isRowCapIsEnabled == true && rowCapValue == null) { - if(verboseLevel >= 1) { - console.warn("RowCap is enabled but the RowCapValue is not set - Acting as if RowCap was not enabled."); +function assertEqual(given, expected) { + if(typeof(given) === "object"){ + if(Array.isArray(given)) { + given+=""; } - isRowCapIsEnabled = false; - } - - //Now our actual logic begins - if(isGeneralCapEnabled == false && isRowCapIsEnabled == false) { - return null; //No cap available to return - } - - - if(isRowCapIsEnabled == true && rowCapValue == null) { - //console.warn("RowCap is enabled but the RowCapValue is not set"); - return null; } - - if(isGeneralCapEnabled == true) { - switch (presidenceValue) { - case Presidence.General: - //General wins - return generalCapValue; - - case Presidence.Row: - if(isRowCapIsEnabled == true) { - //Row wins - return rowCapValue; - } - return generalCapValue; - - case Presidence.Highest: - if(isRowCapIsEnabled == true) { - //Figure out which is higher - if(rowCapValue > generalCapValue) { - //Row wins - return rowCapValue; - } - } - return generalCapValue; - - case Presidence.Lowest: - if(isRowCapIsEnabled == true) { - if(rowCapValue < generalCapValue) { - //Row wins - return rowCapValue; - } - } - return generalCapValue; - - default: - return generalCapValue; + if(typeof(expected) === "object"){ + if(Array.isArray(expected)) { + expected+=""; } - - return generalCapValue; } - //If we made it here then generalCap is not enabled but the row cap may still be enabled - if(isRowCapIsEnabled == true) { - return rowCapValue; - } - - //We should never get here - return null; -} - -//Setup our scenarios and expected values -const useCases = getUseCases_where_only_a_GeneralCap_can_be_triggered(); -const expectedOutcomes = getExpectedOutcomes_where_only_a_GeneralCap_can_be_triggered(); -const verboseLevel = 0; - -//const testResults = executeTests(useCases, expectedOutcomes, verboseLevel); - -function assertEqual(given, expected) { let areEqual = (given == expected); let retVal = {}; retVal.details = given +"=="+ expected; @@ -1239,138 +1275,210 @@ function print(name, test){ function test_GetTrueCaps_ReturnsExpectedValues(){ //#General Presidence //Neither caps enabled - print("a1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, null, null), null)); - print("a2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, null, 400), null)); - print("a3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, null), null)); - print("a4", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 200), null)); - print("a5", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 300), null)); - print("a6", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 400), null)); + print("a1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, null, null).value, null)); + print("a2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, null, 400).value, null)); + print("a3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, null).value, null)); + print("a4", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 200).value, null)); + print("a5", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 300).value, null)); + print("a6", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 400).value, null)); //Only General cap enabled ***** - print("b1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, null, null), null)); //Invalid situation -> a1 - print("b2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, null, 400), null)); //Invalid situation -> a2 - print("b3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, null), 300)); - print("b4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 200), 300)); - print("b5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 300), 300)); - print("b6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 400), 300)); + print("b1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, null, null).value, null)); //Invalid situation -> a1 + print("b2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, null, 400).value, null)); //Invalid situation -> a2 + print("b3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, null).value, 300)); + print("b4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 200).value, 300)); + print("b5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 300).value, 300)); + print("b6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 400).value, 300)); //Both Caps are enabled ***** ***** ^^^^^ - print("c1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, null, null), null)); //Invalid situation -> a1 - print("c2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, null, 400), 400)); //Invalid situation -> d2 - print("c3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, null), 300)); //Invalid situation -> b3 - print("c4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 200), 300)); - print("c5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 300), 300)); - print("c6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 400), 300)); + print("c1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, null, null).value, null)); //Invalid situation -> a1 + print("c2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, null, 400).value, 400)); //Invalid situation -> d2 + print("c3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, null).value, 300)); //Invalid situation -> b3 + print("c4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 200).value, 300)); + print("c5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 300).value, 300)); + print("c6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 400).value, 300)); //Only Row Cap enabled ***** - print("d1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, null, null), null)); //Invalid situation -> a1 - print("d2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, null, 400), 400)); - print("d3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, null), null)); //Invalid situation -> a3 - print("d4", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 200), 200)); - print("d5", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 300), 300)); - print("d6", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 400), 400)); + print("d1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, null, null).value, null)); //Invalid situation -> a1 + print("d2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, null, 400).value, 400)); + print("d3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, null).value, null)); //Invalid situation -> a3 + print("d4", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 200).value, 200)); + print("d5", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 300).value, 300)); + print("d6", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 400).value, 400)); //#Row Presidence //Neither caps enabled - print("a1.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, null, null), null)); - print("a2.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, null, 400), null)); - print("a3.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, null), null)); - print("a4.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, 200), null)); - print("a5.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, 300), null)); - print("a6.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, 400), null)); + print("a1.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, null, null).value, null)); + print("a2.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, null, 400).value, null)); + print("a3.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, null).value, null)); + print("a4.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, 200).value, null)); + print("a5.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, 300).value, null)); + print("a6.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Row, 300, 400).value, null)); //Only General cap enabled ***** - print("b1.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, null, null), null)); //Invalid situation -> a1.1 - print("b2.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, null, 400), null)); //Invalid situation -> a2.1 - print("b3.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, null), 300)); - print("b4.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, 200), 300)); - print("b5.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, 300), 300)); - print("b6.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, 400), 300)); + print("b1.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, null, null).value, null)); //Invalid situation -> a1.1 + print("b2.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, null, 400).value, null)); //Invalid situation -> a2.1 + print("b3.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, null).value, 300)); + print("b4.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, 200).value, 300)); + print("b5.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, 300).value, 300)); + print("b6.1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Row, 300, 400).value, 300)); //Both Caps are enabled ***** ***** ^^^^^ - print("e1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, null, null), null)); //Invalid situation -> a1.1 - print("e2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, null, 400), 400)); //Invalid situation -> d2.1 - print("e3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, null), 300)); //Invalid situation -> b3.1 - print("e4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 200), 200)); - print("e5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 300), 300)); - print("e6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 400), 400)); + print("e1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, null, null).value, null)); //Invalid situation -> a1.1 + print("e2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, null, 400).value, 400)); //Invalid situation -> d2.1 + print("e3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, null).value, 300)); //Invalid situation -> b3.1 + print("e4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 200).value, 200)); + print("e5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 300).value, 300)); + print("e6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 400).value, 400)); //Only Row Cap enabled ***** - print("d1.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, null, null), null)); //Invalid situation -> a1.1 - print("d2.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, null, 400), 400)); - print("d3.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, null), null)); //Invalid situation -> a3.1 - print("d4.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, 200), 200)); - print("d5.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, 300), 300)); - print("d6.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, 400), 400)); + print("d1.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, null, null).value, null)); //Invalid situation -> a1.1 + print("d2.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, null, 400).value, 400)); + print("d3.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, null).value, null)); //Invalid situation -> a3.1 + print("d4.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, 200).value, 200)); + print("d5.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, 300).value, 300)); + print("d6.1", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Row, 300, 400).value, 400)); //#Highest Presidence //Neither caps enabled - print("a1.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, null, null), null)); - print("a2.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, null, 400), null)); - print("a3.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, null), null)); - print("a4.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, 200), null)); - print("a5.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, 300), null)); - print("a6.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, 400), null)); + print("a1.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, null, null).value, null)); + print("a2.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, null, 400).value, null)); + print("a3.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, null).value, null)); + print("a4.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, 200).value, null)); + print("a5.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, 300).value, null)); + print("a6.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Highest, 300, 400).value, null)); //Only General cap enabled ***** - print("b1.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, null, null), null)); //Invalid situation -> a1.2 - print("b2.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, null, 400), null)); //Invalid situation -> a2.2 - print("b3.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, null), 300)); - print("b4.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, 200), 300)); - print("b5.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, 300), 300)); - print("b6.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, 400), 300)); + print("b1.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, null, null).value, null)); //Invalid situation -> a1.2 + print("b2.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, null, 400).value, null)); //Invalid situation -> a2.2 + print("b3.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, null).value, 300)); + print("b4.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, 200).value, 300)); + print("b5.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, 300).value, 300)); + print("b6.2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Highest, 300, 400).value, 300)); //Both Caps are enabled ***** ***** ^^^^^ - print("f1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, null, null), null)); //Invalid situation -> a1.2 - print("f2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, null, 400), 400)); //Invalid situation -> d2.2 - print("f3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, null), 300)); //Invalid situation -> b3.2 - print("f4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 200), 300)); - print("f5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 300), 300)); - print("f6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 400), 400)); + print("f1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, null, null).value, null)); //Invalid situation -> a1.2 + print("f2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, null, 400).value, 400)); //Invalid situation -> d2.2 + print("f3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, null).value, 300)); //Invalid situation -> b3.2 + print("f4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 200).value, 300)); + print("f5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 300).value, 300)); + print("f6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 400).value, 400)); //Only Row Cap enabled ***** - print("d1.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, null, null), null)); //Invalid situation -> a1.2 - print("d2.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, null, 400), 400)); - print("d3.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, null), null)); //Invalid situation => a3.2 - print("d4.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, 200), 200)); - print("d5.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, 300), 300)); - print("d6.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, 400), 400)); + print("d1.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, null, null).value, null)); //Invalid situation -> a1.2 + print("d2.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, null, 400).value, 400)); + print("d3.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, null).value, null)); //Invalid situation => a3.2 + print("d4.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, 200).value, 200)); + print("d5.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, 300).value, 300)); + print("d6.2", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Highest, 300, 400).value, 400)); //#Lowest Presidence //Neither caps enabled - print("a1.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, null, null), null)); - print("a2.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, null, 400), null)); - print("a3.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, null), null)); - print("a4.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 200), null)); - print("a5.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 300), null)); - print("a6.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 400), null)); + print("a1.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, null, null).value, null)); + print("a2.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, null, 400).value, null)); + print("a3.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, null).value, null)); + print("a4.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 200).value, null)); + print("a5.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 300).value, null)); + print("a6.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 400).value, null)); //Only General cap enabled ***** - print("b1.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, null, null), null)); //Invalid situation -> a1.3 - print("b2.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, null, 400), null)); //Invalid situation -> a2.3 - print("b3.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, null), 300)); - print("b4.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 200), 300)); - print("b5.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 300), 300)); - print("b6.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 400), 300)); + print("b1.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, null, null).value, null)); //Invalid situation -> a1.3 + print("b2.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, null, 400).value, null)); //Invalid situation -> a2.3 + print("b3.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, null).value, 300)); + print("b4.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 200).value, 300)); + print("b5.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 300).value, 300)); + print("b6.3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.Lowest, 300, 400).value, 300)); //Both Caps are enabled ***** ***** ^^^^^ - print("g1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, null, null), null)); //Invalid situation -> a1.3 - print("g2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, null, 400), 400)); //Invalid situation -> d2.3 - print("g3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, null), 300)); //Invalid situation -> b3.3 - print("g4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 200), 200)); - print("g5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 300), 300)); - print("g6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 400), 300)); + print("g1", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, null, null).value, null)); //Invalid situation -> a1.3 + print("g2", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, null, 400).value, 400)); //Invalid situation -> d2.3 + print("g3", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, null).value, 300)); //Invalid situation -> b3.3 + print("g4", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 200).value, 200)); + print("g5", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 300).value, 300)); + print("g6", assertEqual(getTrueCap(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 400).value, 300)); //Only Row Cap enabled ***** - print("d1.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, null, null), null)); //Invalid situation -> a1.3 - print("d2.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, null, 400), 400)); - print("d3.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, null), null)); //Invalid situation -> a3.3 - print("d4.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 200), 200)); - print("d5.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 300), 300)); - print("d6.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 400), 400)); + print("d1.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, null, null).value, null)); //Invalid situation -> a1.3 + print("d2.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, null, 400).value, 400)); + print("d3.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, null).value, null)); //Invalid situation -> a3.3 + print("d4.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 200).value, 200)); + print("d5.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 300).value, 300)); + print("d6.3", assertEqual(getTrueCap(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 400).value, 400)); + + +console.log(""); + /////// + //#INCLUDE CAPTRIGGER IN THE TESTS + + //#General Presidence + //Neither caps enabled + print("a1", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, null, null), [CapTrigger.None,null])); + print("a2", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, null, 400), [CapTrigger.None,null])); + print("a3", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, null), [CapTrigger.None,null])); + print("a4", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 200), [CapTrigger.None,null])); + print("a5", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 300), [CapTrigger.None,null])); + print("a6", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapNotEnabled, Presidence.General, 300, 400), [CapTrigger.None,null])); + + //Only General cap enabled ***** + print("b1", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, null, null), [CapTrigger.None,null])); //Invalid situation -> a1 + print("b2", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, null, 400), [CapTrigger.None,null])); //Invalid situation -> a2 + print("b3", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, null), [CapTrigger.General,300])); + print("b4", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 200), [CapTrigger.General,300])); + print("b5", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 300), [CapTrigger.General,300])); + print("b6", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapNotEnabled, Presidence.General, 300, 400), [CapTrigger.General,300])); + + //Both Caps are enabled ***** ***** ^^^^^ + print("c1", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, null, null), [CapTrigger.None,null])); //Invalid situation -> a1 + print("c2", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, null, 400), [CapTrigger.Row,400])); //Invalid situation -> d2 + print("c3", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, null), [CapTrigger.General,300])); //Invalid situation -> b3 + print("c4", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 200), [CapTrigger.General,300])); + print("c5", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 300), [CapTrigger.General,300])); + print("c6", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.General, 300, 400), [CapTrigger.General,300])); + + //Only Row Cap enabled ***** + print("d1", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, null, null), [CapTrigger.None,null])); //Invalid situation -> a1 + print("d2", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, null, 400), [CapTrigger.Row,400])); + print("d3", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, null), [CapTrigger.None,null])); //Invalid situation -> a3 + print("d4", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 200), [CapTrigger.Row,200])); + print("d5", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 300), [CapTrigger.Row,300])); + print("d6", assertEqual(getTrueCapAsTestResult(GeneralCapNotEnabled, RowCapIsEnabled, Presidence.General, 300, 400), [CapTrigger.Row,400])); + + //#Row Presidence + //Both Caps are enabled ***** ***** ^^^^^ + print("e1", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, null, null), [CapTrigger.None,null])); //Invalid situation -> a1.1 + print("e2", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, null, 400), [CapTrigger.Row,400])); //Invalid situation -> d2.1 + print("e3", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, null), [CapTrigger.General,300])); //Invalid situation -> b3.1 + print("e4", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 200), [CapTrigger.Row,200])); + print("e5", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 300), [CapTrigger.Row,300])); + print("e6", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Row, 300, 400), [CapTrigger.Row,400])); + + //#Highest Presidence + //Both Caps are enabled ***** ***** ^^^^^ + print("f1", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, null, null), [CapTrigger.None,null])); //Invalid situation -> a1.2 + print("f2", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, null, 400), [CapTrigger.Row,400])); //Invalid situation -> d2.2 + print("f3", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, null), [CapTrigger.General,300])); //Invalid situation -> b3.2 + print("f4", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 200), [CapTrigger.General,300])); + print("f5", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 300), [CapTrigger.General,300])); + print("f6", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Highest, 300, 400), [CapTrigger.Row,400])); + + //#Lowest Presidence + //Both Caps are enabled ***** ***** ^^^^^ + print("g1", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, null, null), [CapTrigger.None,null])); //Invalid situation -> a1.3 + print("g2", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, null, 400), [CapTrigger.Row,400])); //Invalid situation -> d2.3 + print("g3", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, null), [CapTrigger.General,300])); //Invalid situation -> b3.3 + print("g4", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 200), [CapTrigger.Row,200])); + print("g5", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 300), [CapTrigger.General,300])); + print("g6", assertEqual(getTrueCapAsTestResult(GeneralCapIsEnabled, RowCapIsEnabled, Presidence.Lowest, 300, 400), [CapTrigger.General,300])); + } -test_GetTrueCaps_ReturnsExpectedValue(); +//Setup our scenarios and expected values +const useCases = getUseCases_where_only_a_GeneralCap_can_be_triggered(); +const expectedOutcomes = getExpectedOutcomes_where_only_a_GeneralCap_can_be_triggered(); +const verboseLevel = 0; +//const testResults = executeTests(useCases, expectedOutcomes, verboseLevel); + +test_GetTrueCaps_ReturnsExpectedValues(); /* @@ -1379,9 +1487,8 @@ test_GetTrueCaps_ReturnsExpectedValue(); [ ] Define all expectedOutcomes (write code to write the code?) [ ] Define all useCases (write code to write the code?) [x] test_GetTrueCaps_ReturnsExpectedValue passes all tests - [ ] Code function getBid(tieBid, trueCap, myBid, adjustedBid) - Returns [capWasTriggered, adjustedBid] - + [x] Code function getTrueCaps(getTrueCap(isGeneralCapEnabled, isRowCapIsEnabled, presidenceValue, generalCapValue, rowCapValue) Returns {trigger. value} + [ ] Code function getBid(tieBid, trueCap, myBid, adjustedBid) Returns [capWasTriggered, adjustedBid] */