From cc0a69e15bea863c08bfcb4f9ceebf19259bba6c Mon Sep 17 00:00:00 2001 From: Steven Date: Wed, 6 Dec 2023 17:04:41 -0800 Subject: [PATCH] Added getTrueCap method to test.js and added tests --- README.md | 39 ++++--- test.js | 313 ++++++++++++++++++++++++++++++++++++++++-------------- 2 files changed, 254 insertions(+), 98 deletions(-) diff --git a/README.md b/README.md index f55448d..33be742 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,8 @@ To load the Tampermonkey script: ## Wishlist / Todo ### Functionality For Release +- [ ] Add this link to the settings div: https://leads.needtosellmyhousefast.com/qhrei +- [ ] Add donation/support message to div - [ ] Read from /app/subscriptions to get list of initial counties - if county is missing it automatically gets added. - [x] Expose Sitewide bidcap (if any county bid exceeds X only bid up to X for that county) - [x] Save button to persist changes (instead of waiting for refresh code to run) @@ -21,25 +23,13 @@ To load the Tampermonkey script: - [ ] Implement tieCounty code - [ ] Implement watchCounty code - [x] Add cap presidence setting. -- [ ] Add General Cap Applies to option - - *If a row and settings cap are enabled then [options🔽] takes presidence.* - ```Options - G - GeneralBidCap - R - RowCap - H - The highest cap - L - The lowest cap - ``` -- [ ] Apply cap presidence logic -- [ ] Add settings option on where to apply the SettingsBidCap. +- [x] Add Presidence option to settings div - *SettingsBidCap [200] applies to [options🔽] rows* - ```Options - N - None of the - A - All - C - Capped Only - U - UnCapped Only + *If a row and general cap are enabled then [options🔽] takes presidence.* + ``` + Options = [General Cap, Row Cap, Highest Cap, Lowest Cap] ``` +- [ ] Apply presidence logic to get true cap ### Feature Requests / Future Releases - [ ] Post stats to API instead of storing in local storage @@ -54,11 +44,20 @@ To load the Tampermonkey script: - [ ] expose toggle to hide/show ignored counties in settings (not at row level but read for ignore action at each level) - [ ] prices based on schedule (dont win ant night...) - [ ] schedule derived from statistical analysis gathered over time. +- [ ] cooloff time (auto drops all bids for a specified amount of time then continues to win again.) +- [ ] Add settings option on where to apply the GeneralBidCap + + *SettingsBidCap [200] applies to [options🔽] rows* + ``` + Options = [None of the, All, Capped Only, Uncapped Only] + ``` + ### Bugs - [ ] Figure out session timout/no longer refreshing/ not loaded issue (screensaver?, tab no focus?, os?, browser?) - [ ] if oversight div exists for county don't inject a new one +- [ ] if autoRefresh is not enabled DO NOT adjust bids on load (wait for the first refresh) (possibly expose "don't adjust bids on load" checkbox) ### UI Settings @@ -67,7 +66,7 @@ To load the Tampermonkey script: ### UI Rows - [x] "rowAction" dropdown with options: - ```[ + ``` 0 - Ignore/Hide = Make this row invisible. 1 - Win = Ensure I am highest bidder 2 - Tie = Make sure I am Tied @@ -79,8 +78,8 @@ To load the Tampermonkey script: - [x] Auto login if on signin page - [x] Add verticle scroll overflow to awLog div - [x] Refactor injection and alwayswin array code in main -- [] Bidcap input for row is only visible if cap is checked for row or settings bidcap is enabled. -- [] Refactor Row injections layout to be: +- [ ] Bidcap input for row is only visible if cap is checked for row or settings bidcap is enabled. +- [ ] Refactor Row injections layout to be: MYBID: 500 11223 margin:0 [Win🔽] 475 |☐cap diff --git a/test.js b/test.js index e6531df..19596e1 100644 --- a/test.js +++ b/test.js @@ -33,7 +33,9 @@ const TestResult = Object.freeze({ //Declare some readability constants const CapIsTriggered = true; //myBid is over the targetCap the cap is enabled in some way for the row) const GeneralCapIsEnabled = true; //The generalCap checkbox is checked +const GeneralCapNotEnabled = false; const RowCapIsEnabled = true; //The rowCap checkBox is checked for the county +const RowCapNotEnabled = false; function newResult(capIsTriggered, reasonNum, trueCapNum, capSource, myBidNum) { @@ -149,7 +151,6 @@ function executeTests(scenarios, expectations, verboseLevel) { return allTestsPassed; } - function getTest(testId) { //TODO: THIS CODE IS AN IDEA AND IS NOT USED YET let test = {}; @@ -1137,94 +1138,250 @@ 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; + } + + 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 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; + } + + 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 = 2; +const verboseLevel = 0; -const testResults = executeTests(useCases, expectedOutcomes, verboseLevel); +//const testResults = executeTests(useCases, expectedOutcomes, verboseLevel); +function assertEqual(given, expected) { + let areEqual = (given == expected); + let retVal = {}; + retVal.details = given +"=="+ expected; + retVal.result = areEqual ? TestResult.Pass: TestResult.Fail; + return retVal; +} + +function print(name, test){ + if(test.result == TestResult.Fail){ + console.log(name +"\t*"+test.result +"*\t"+ test.details ); + } else { + console.log(name +"\t"+test.result +"\t"+ test.details ); + } +} + +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)); + + //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)); + + //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)); + + //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)); + + //#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)); + + //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)); + + //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)); + + //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)); + + //#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)); + + //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)); + + //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)); + + //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)); + + //#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)); + + //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)); + + //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)); + + //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)); +} + +test_GetTrueCaps_ReturnsExpectedValue(); /* # DEV LOG ## TODO: - [ ] Define all expectedOutcomes - [ ] Define all useCases - -### Scenarios where no caps of any kind could ever be triggered, Presidence does not apply and neither does the appliesTo - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.Uncapped - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.Uncapped - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.Uncapped - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.Uncapped - -### Scenarios where only a row cap could ever be triggered, Presidence does not apply and neither does the appliesTo - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.Uncapped - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.Uncapped - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.Uncapped - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.All - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.None - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.Capped - [ ] Pass all tests for: !GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.Uncapped - -### Scenarios where only a general cap could ever be triggered, Presidence does not apply BUT appliesTo does sometimes - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.General + AppliesTo.Uncapped - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Row + AppliesTo.Uncapped - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Highest + AppliesTo.Uncapped - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + !RowCapIsEnabled + Presidence.Lowest + AppliesTo.Uncapped - -### Scenarios where only Either cap could potentailly be triggered, Presidence AND appliesTo also affects the outcome - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.General + AppliesTo.Uncapped - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Row + AppliesTo.Uncapped - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Highest + AppliesTo.Uncapped - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.All - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.None - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.Capped - [ ] Pass all tests for: GeneralCapIsEnabled + RowCapIsEnabled + Presidence.Lowest + AppliesTo.Uncapped - + [ ] 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] + */