Page MenuHomeWildfire Games

Add a MultiKeyMap helper and tests (+ allow tests in /helpers) - D274 prereq
Needs ReviewPublic

Authored by wraitii on Sun, May 5, 6:02 PM.

Details

Reviewers
None
Group Reviewers
Restricted Owners Package(Owns No Changed Paths)
Summary

In prevision of D274, the adds a MultiKeyMap class to handle the modifications storage.
This adds tests (I believe I have 100% coverage) and the ability to add tests to helpers/ directly.

Test Plan

Review code / tests

Diff Detail

Event Timeline

wraitii created this revision.Sun, May 5, 6:02 PM
wraitii retitled this revision from Add a MultiKeyMap helper and tests (+ allow tests in /helpers) - D278 prereq to Add a MultiKeyMap helper and tests (+ allow tests in /helpers) - D274 prereq.Sun, May 5, 6:05 PM
wraitii edited the summary of this revision. (Show Details)
Vulcan added a comment.Sun, May 5, 6:09 PM

Successful build - Chance fights ever on the side of the prudent.

Linter detected issues:
Executing section Source...

source/simulation2/components/tests/test_scripts.h
|   1| /*·Copyright·(C)·2017·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2019" year instead of "2017"
Executing section JS...
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|   8|   8| 	map.AddItem("prim_a", "item_a", 0, "sec_b");
|   9|   9| 	map.AddItem("prim_b", "item_a", 0, "sec_a");
|  10|  10| 	map.AddItem("prim_c", "item_a", 0, "sec_a");
|  11|    |-};
|    |  11|+}
|  12|  12| 
|  13|  13| // Check that key-related operations are correct.
|  14|  14| function test_keys(map)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  13|  13| // Check that key-related operations are correct.
|  14|  14| function test_keys(map)
|  15|  15| {
|  16|    |-	TS_ASSERT(map.items.has("prim_a"))
|    |  16|+	TS_ASSERT(map.items.has("prim_a"));
|  17|  17| 	TS_ASSERT(map.items.has("prim_b"))
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  14|  14| function test_keys(map)
|  15|  15| {
|  16|  16| 	TS_ASSERT(map.items.has("prim_a"))
|  17|    |-	TS_ASSERT(map.items.has("prim_b"))
|    |  17|+	TS_ASSERT(map.items.has("prim_b"));
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  15|  15| {
|  16|  16| 	TS_ASSERT(map.items.has("prim_a"))
|  17|  17| 	TS_ASSERT(map.items.has("prim_b"))
|  18|    |-	TS_ASSERT(map.items.has("prim_c"))
|    |  18|+	TS_ASSERT(map.items.has("prim_c"));
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  17|  17| 	TS_ASSERT(map.items.has("prim_b"))
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|  20|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    |  20|+	TS_ASSERT(map.items.get("prim_a").has("sec_a"));
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    |  21|+	TS_ASSERT(map.items.get("prim_a").has("sec_b"));
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|    |-	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|    |  22|+	TS_ASSERT(!map.items.get("prim_a").has("sec_c"));
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|    |-	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    |  23|+	TS_ASSERT(map.items.get("prim_b").has("sec_a"));
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|    |-	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    |  24|+	TS_ASSERT(map.items.get("prim_c").has("sec_a"));
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|  26|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    |  26|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3);
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|    |  27|+	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1);
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  28|    |-	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|    |  28|+	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1);
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|    |-	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|    |  29|+	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1);
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|  31|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    |  31|+	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3);
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|    |  32|+	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1);
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  33|    |-	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|    |  33|+	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1);
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|    |-	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|    |  34|+	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1);
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|  36|    |-	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|    |  36|+	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"));
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|    |-	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|    |  37|+	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"));
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|    |-	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|    |  38|+	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"));
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|    |  39|+	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"));
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|    |-	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|    |  40|+	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"));
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|    |  41|+	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"));
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|    |  42|+	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"));
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|    |-	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|    |  43|+	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"));
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|    |-	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|    |  44|+	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"));
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|    |-	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|    |  45|+	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"));
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|    |-	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|    |  46|+	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"));
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  49|  49| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|    |-	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|    |  47|+	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"));
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  48|    |-	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|    |  48|+	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"));
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|  51|    |-	map.AddItem("prim_a", "item_b", 0, "sec_a")
|    |  51|+	map.AddItem("prim_a", "item_b", 0, "sec_a");
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  52|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    |  52|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3);
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  50|  50| 	// Adding the same item increases its count.
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|    |  53|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2);
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  56|  56| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    |  54|+	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3);
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  55|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|    |  55|+	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4);
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  58|  58| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  58|    |-	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|    |  58|+	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"));
|  59|  59| 	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|  60|  60| 
|  61|  61| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  58|  58| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|  59|    |-	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|    |  59|+	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true));
|  60|  60| 
|  61|  61| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|  62|  62| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  58|  58| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|  59|  59| 	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|  60|  60| 
|  61|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|    |  61|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4);
|  62|  62| 
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  61|  61| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|  62|  62| 
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|    |-	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  64|+	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"));
|  65|  65| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  66|  66| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  62|  62| 
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  65|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|    |  65|+	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true));
|  66|  66| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  68|  68| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  65|  65| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  66|    |-	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  66|+	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"));
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  65|  65| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  66|  66| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  67|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  67|+	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"));
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|  70|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|    |  70|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2);
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  71|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|    |  71|+	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"));
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  69|  69| 	// Check that cleanup is done
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|    |  72|+	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"));
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|    |-	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    |  73|+	TS_ASSERT(!map.items.get("prim_a").has("sec_a"));
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    |  74|+	TS_ASSERT(map.items.get("prim_a").has("sec_b"));
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|  77|  77| };
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|    |  75|+	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"));
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|  77|  77| };
|  78|  78| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|    |-	TS_ASSERT(!map.items.has("prim_a"))
|    |  76|+	TS_ASSERT(!map.items.has("prim_a"));
|  77|  77| };
|  78|  78| 
|  79|  79| function setup_items(map)
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|  77|    |-};
|    |  77|+}
|  78|  78| 
|  79|  79| function setup_items(map)
|  80|  80| {
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  85|  85| 	map.AddItem("prim_a", "item_a", 5, "sec_b");
|  86|  86| 	map.AddItem("prim_b", "item_a", 6, "sec_a");
|  87|  87| 	map.AddItem("prim_c", "item_a", 7, "sec_a");
|  88|    |-};
|    |  88|+}
|  89|  89| 
|  90|  90| // Check that items returned are correct.
|  91|  91| function test_items(map)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  91|  91| function test_items(map)
|  92|  92| {
|  93|  93| 	let items = map.GetAllItems("sec_a");
|  94|    |-	TS_ASSERT("prim_a" in items)
|    |  94|+	TS_ASSERT("prim_a" in items);
|  95|  95| 	TS_ASSERT("prim_b" in items)
|  96|  96| 	TS_ASSERT("prim_c" in items)
|  97|  97| 	let sum = 0;
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  92|  92| {
|  93|  93| 	let items = map.GetAllItems("sec_a");
|  94|  94| 	TS_ASSERT("prim_a" in items)
|  95|    |-	TS_ASSERT("prim_b" in items)
|    |  95|+	TS_ASSERT("prim_b" in items);
|  96|  96| 	TS_ASSERT("prim_c" in items)
|  97|  97| 	let sum = 0;
|  98|  98| 	for (let key in items)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  93|  93| 	let items = map.GetAllItems("sec_a");
|  94|  94| 	TS_ASSERT("prim_a" in items)
|  95|  95| 	TS_ASSERT("prim_b" in items)
|  96|    |-	TS_ASSERT("prim_c" in items)
|    |  96|+	TS_ASSERT("prim_c" in items);
|  97|  97| 	let sum = 0;
|  98|  98| 	for (let key in items)
|  99|  99| 		items[key].forEach(item => sum += item);
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  97|  97| 	let sum = 0;
|  98|  98| 	for (let key in items)
|  99|  99| 		items[key].forEach(item => sum += item);
| 100|    |-	TS_ASSERT(sum == 19)
|    | 100|+	TS_ASSERT(sum == 19);
| 101| 101| 
| 102| 102| 	items = map.GetAllItems("sec_a", true);
| 103| 103| 	sum = 0;
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 104| 104| 	for (let key in items)
| 105| 105| 		items[key].forEach(item => sum += item);
| 106| 106| 	// We're adding more of the first item_c, the value wasn't replaced.
| 107|    |-	TS_ASSERT(sum == 22)
|    | 107|+	TS_ASSERT(sum == 22);
| 108| 108| };
| 109| 109| 
| 110| 110| // Test items, and test that deserialised versions still pass test (i.e. test serialisation).
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 105| 105| 		items[key].forEach(item => sum += item);
| 106| 106| 	// We're adding more of the first item_c, the value wasn't replaced.
| 107| 107| 	TS_ASSERT(sum == 22)
| 108|    |-};
|    | 108|+}
| 109| 109| 
| 110| 110| // Test items, and test that deserialised versions still pass test (i.e. test serialisation).
| 111| 111| let map = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 115| 115| map = new MultiKeyMap();
| 116| 116| let map2 = new MultiKeyMap();
| 117| 117| setup_keys(map);
| 118|    |-map2.Deserialize(map.Serialize())
|    | 118|+map2.Deserialize(map.Serialize());
| 119| 119| test_keys(map2);
| 120| 120| 
| 121| 121| map = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 119| 119| test_keys(map2);
| 120| 120| 
| 121| 121| map = new MultiKeyMap();
| 122|    |-setup_items(map)
|    | 122|+setup_items(map);
| 123| 123| test_items(map);
| 124| 124| map = new MultiKeyMap();
| 125| 125| map2 = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 124| 124| map = new MultiKeyMap();
| 125| 125| map2 = new MultiKeyMap();
| 126| 126| setup_items(map);
| 127|    |-map2.Deserialize(map.Serialize())
|    | 127|+map2.Deserialize(map.Serialize());
| 128| 128| test_items(map2);

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  99| »   »   items[key].forEach(item·=>·sum·+=·item);
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 105| »   »   items[key].forEach(item·=>·sum·+=·item);
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  11| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  16| »   TS_ASSERT(map.items.has("prim_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  17| »   TS_ASSERT(map.items.has("prim_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  18| »   TS_ASSERT(map.items.has("prim_c"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  20| »   TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  21| »   TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  22| »   TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  23| »   TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  24| »   TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  26| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  27| »   TS_ASSERT(map.items.get("prim_a").get("sec_b").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  28| »   TS_ASSERT(map.items.get("prim_b").get("sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  29| »   TS_ASSERT(map.items.get("prim_c").get("sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  31| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  32| »   TS_ASSERT(map.GetItems("prim_a",·"sec_b").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  33| »   TS_ASSERT(map.GetItems("prim_b",·"sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  34| »   TS_ASSERT(map.GetItems("prim_c",·"sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  36| »   TS_ASSERT(map.HasItem("prim_a",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  37| »   TS_ASSERT(map.HasItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  38| »   TS_ASSERT(map.HasItem("prim_a",·"item_c",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  39| »   TS_ASSERT(!map.HasItem("prim_a",·"item_d",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  40| »   TS_ASSERT(map.HasItem("prim_a",·"item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  41| »   TS_ASSERT(!map.HasItem("prim_a",·"item_b",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  42| »   TS_ASSERT(!map.HasItem("prim_a",·"item_c",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  43| »   TS_ASSERT(map.HasItem("prim_b",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  44| »   TS_ASSERT(map.HasItem("prim_c",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  45| »   TS_ASSERT(map.HasAnyItem("item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  46| »   TS_ASSERT(map.HasAnyItem("item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  47| »   TS_ASSERT(!map.HasAnyItem("item_d",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  48| »   TS_ASSERT(!map.HasAnyItem("item_b",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  51| »   map.AddItem("prim_a",·"item_b",·0,·"sec_a")
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  52| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  53| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item·=>·item.ID·==·"item_b")[0].count·==·2)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  54| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  55| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a",·true).length·==·4)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  58| »   TS_ASSERT(!map.AddItem("prim_a",·"item_b",·0,·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  59| »   TS_ASSERT(map.AddItem("prim_a",·"item_b",·0,·"sec_a",·true))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  61| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item·=>·item.ID·==·"item_b")[0].count·==·4)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  64| »   TS_ASSERT(!map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  65| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_b",·"sec_a",·true))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  66| »   TS_ASSERT(!map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  67| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  70| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·2)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  71| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  72| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_c",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  73| »   TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  74| »   TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  75| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  76| »   TS_ASSERT(!map.items.has("prim_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  77| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  77| };
|    | [MAJOR] JSHintBear:
|    | Too many errors. (59% scanned).
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|   6|   6| {
|   7|   7| 	this.items = new Map();
|   8|   8| 	// Keys are referred to as 'primaryKey', 'secondaryKey', 'itemID'.
|   9|    |-};
|    |   9|+}
|  10|  10| 
|  11|  11| MultiKeyMap.prototype.Serialize = function()
|  12|  12| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 155| 155| 	if (!this._exists(primaryKey, secondaryKey))
| 156| 156| 		return [];
| 157| 157| 	return this.items.get(primaryKey).get(secondaryKey);
| 158|    |-}
|    | 158|+};
| 159| 159| 
| 160| 160| /**
| 161| 161|  * @returns a reference to the list of items for that property name and secondaryKey.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 165| 165| 	if (!this._exists(primaryKey, secondaryKey))
| 166| 166| 		this._initItemsIfNeeded(primaryKey, secondaryKey);
| 167| 167| 	return this.items.get(primaryKey).get(secondaryKey);
| 168|    |-}
|    | 168|+};
| 169| 169| 
| 170| 170| MultiKeyMap.prototype._exists = function(primaryKey, secondaryKey)
| 171| 171| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 174| 174| 	if (!this.items.get(primaryKey).get(secondaryKey))
| 175| 175| 		return false;
| 176| 176| 	return true;
| 177|    |-}
|    | 177|+};
| 178| 178| 
| 179| 179| MultiKeyMap.prototype._initItemsIfNeeded = function(primaryKey, secondaryKey)
| 180| 180| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 182| 182| 		this.items.set(primaryKey, new Map());
| 183| 183| 	if (!this.items.get(primaryKey).get(secondaryKey))
| 184| 184| 		this.items.get(primaryKey).set(secondaryKey, []);
| 185|    |-}
|    | 185|+};
| 186| 186| 
| 187| 187| /**
| 188| 188|  * @returns true if the items list changed in such a way that cached values are possibly invalidated.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 124| »   »   this._getItems(primaryKey,·secondaryKey).forEach(item·=>·items·=·items.concat(Array(item.count).fill(item.value)));
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 194| »   let·existingItems·=·items.filter(item·=>·{·return·item.ID·==·itemID;·});
|    | [NORMAL] ESLintBear (no-shadow):
|    | 'item' is already declared in the upper scope.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|   9| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 158| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 168| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 177| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 185| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.
Executing section cli...

Link to build: https://jenkins.wildfiregames.com/job/differential/1327/display/redirect

wraitii updated this revision to Diff 7912.Sun, May 5, 6:38 PM

Turns out GetPathnames called Clear() so this actually disabled tests in components/
I've checked everywhere and that behaviour is never useful, and it seems quite counter-intuitive to me, so I've simply removed the call to Clear().

Vulcan added a comment.Sun, May 5, 6:40 PM

Successful build - Chance fights ever on the side of the prudent.

Linter detected issues:
Executing section Source...

source/simulation2/components/tests/test_scripts.h
|   1| /*·Copyright·(C)·2017·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2019" year instead of "2017"

source/lib/file/vfs/vfs_util.cpp
|   1| /*·Copyright·(C)·2015·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2019" year instead of "2015"
Executing section JS...
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|   8|   8| 	map.AddItem("prim_a", "item_a", 0, "sec_b");
|   9|   9| 	map.AddItem("prim_b", "item_a", 0, "sec_a");
|  10|  10| 	map.AddItem("prim_c", "item_a", 0, "sec_a");
|  11|    |-};
|    |  11|+}
|  12|  12| 
|  13|  13| // Check that key-related operations are correct.
|  14|  14| function test_keys(map)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  13|  13| // Check that key-related operations are correct.
|  14|  14| function test_keys(map)
|  15|  15| {
|  16|    |-	TS_ASSERT(map.items.has("prim_a"))
|    |  16|+	TS_ASSERT(map.items.has("prim_a"));
|  17|  17| 	TS_ASSERT(map.items.has("prim_b"))
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  14|  14| function test_keys(map)
|  15|  15| {
|  16|  16| 	TS_ASSERT(map.items.has("prim_a"))
|  17|    |-	TS_ASSERT(map.items.has("prim_b"))
|    |  17|+	TS_ASSERT(map.items.has("prim_b"));
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  15|  15| {
|  16|  16| 	TS_ASSERT(map.items.has("prim_a"))
|  17|  17| 	TS_ASSERT(map.items.has("prim_b"))
|  18|    |-	TS_ASSERT(map.items.has("prim_c"))
|    |  18|+	TS_ASSERT(map.items.has("prim_c"));
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  17|  17| 	TS_ASSERT(map.items.has("prim_b"))
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|  20|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    |  20|+	TS_ASSERT(map.items.get("prim_a").has("sec_a"));
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  18|  18| 	TS_ASSERT(map.items.has("prim_c"))
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    |  21|+	TS_ASSERT(map.items.get("prim_a").has("sec_b"));
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  19|  19| 
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|    |-	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|    |  22|+	TS_ASSERT(!map.items.get("prim_a").has("sec_c"));
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  20|  20| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|    |-	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    |  23|+	TS_ASSERT(map.items.get("prim_b").has("sec_a"));
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  22|  22| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|    |-	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    |  24|+	TS_ASSERT(map.items.get("prim_c").has("sec_a"));
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  23|  23| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|  26|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    |  26|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3);
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  24|  24| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|    |  27|+	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1);
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  25|  25| 
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  28|    |-	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|    |  28|+	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1);
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  26|  26| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  27|  27| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|    |-	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|    |  29|+	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1);
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  28|  28| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|  31|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    |  31|+	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3);
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  29|  29| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|    |  32|+	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1);
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  30|  30| 
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  33|    |-	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|    |  33|+	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1);
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  31|  31| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  32|  32| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|    |-	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|    |  34|+	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1);
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  33|  33| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|  36|    |-	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|    |  36|+	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"));
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  34|  34| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|    |-	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|    |  37|+	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"));
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  35|  35| 
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|    |-	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|    |  38|+	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"));
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  36|  36| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|    |  39|+	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"));
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  37|  37| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|    |-	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|    |  40|+	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"));
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  38|  38| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|    |  41|+	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"));
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  39|  39| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|    |  42|+	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"));
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|    |-	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|    |  43|+	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"));
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  41|  41| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|    |-	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|    |  44|+	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"));
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  42|  42| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|    |-	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|    |  45|+	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"));
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  43|  43| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|    |-	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|    |  46|+	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"));
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  49|  49| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  44|  44| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|    |-	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|    |  47|+	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"));
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  45|  45| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  46|  46| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  47|  47| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  48|    |-	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|    |  48|+	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"));
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  48|  48| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|  51|    |-	map.AddItem("prim_a", "item_b", 0, "sec_a")
|    |  51|+	map.AddItem("prim_a", "item_b", 0, "sec_a");
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  49|  49| 
|  50|  50| 	// Adding the same item increases its count.
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  52|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    |  52|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3);
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  50|  50| 	// Adding the same item increases its count.
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|    |  53|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2);
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  56|  56| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  51|  51| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    |  54|+	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3);
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  52|  52| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  53|  53| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  54|  54| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  55|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|    |  55|+	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4);
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  58|  58| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  55|  55| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  58|    |-	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|    |  58|+	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"));
|  59|  59| 	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|  60|  60| 
|  61|  61| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  56|  56| 
|  57|  57| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  58|  58| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|  59|    |-	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|    |  59|+	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true));
|  60|  60| 
|  61|  61| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|  62|  62| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  58|  58| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|  59|  59| 	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|  60|  60| 
|  61|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|    |  61|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4);
|  62|  62| 
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  61|  61| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|  62|  62| 
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|    |-	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  64|+	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"));
|  65|  65| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  66|  66| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  62|  62| 
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  65|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|    |  65|+	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true));
|  66|  66| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  68|  68| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  63|  63| 	// Likewise removing, unless we now reach 0
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  65|  65| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  66|    |-	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  66|+	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"));
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  64|  64| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  65|  65| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  66|  66| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  67|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  67|+	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"));
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  67|  67| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|  70|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|    |  70|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2);
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  68|  68| 
|  69|  69| 	// Check that cleanup is done
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  71|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|    |  71|+	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"));
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  69|  69| 	// Check that cleanup is done
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|    |  72|+	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"));
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  70|  70| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|    |-	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    |  73|+	TS_ASSERT(!map.items.get("prim_a").has("sec_a"));
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    |  74|+	TS_ASSERT(map.items.get("prim_a").has("sec_b"));
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|  77|  77| };
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  72|  72| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|    |  75|+	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"));
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|  77|  77| };
|  78|  78| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  73|  73| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|    |-	TS_ASSERT(!map.items.has("prim_a"))
|    |  76|+	TS_ASSERT(!map.items.has("prim_a"));
|  77|  77| };
|  78|  78| 
|  79|  79| function setup_items(map)
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  76|  76| 	TS_ASSERT(!map.items.has("prim_a"))
|  77|    |-};
|    |  77|+}
|  78|  78| 
|  79|  79| function setup_items(map)
|  80|  80| {
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  85|  85| 	map.AddItem("prim_a", "item_a", 5, "sec_b");
|  86|  86| 	map.AddItem("prim_b", "item_a", 6, "sec_a");
|  87|  87| 	map.AddItem("prim_c", "item_a", 7, "sec_a");
|  88|    |-};
|    |  88|+}
|  89|  89| 
|  90|  90| // Check that items returned are correct.
|  91|  91| function test_items(map)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  91|  91| function test_items(map)
|  92|  92| {
|  93|  93| 	let items = map.GetAllItems("sec_a");
|  94|    |-	TS_ASSERT("prim_a" in items)
|    |  94|+	TS_ASSERT("prim_a" in items);
|  95|  95| 	TS_ASSERT("prim_b" in items)
|  96|  96| 	TS_ASSERT("prim_c" in items)
|  97|  97| 	let sum = 0;
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  92|  92| {
|  93|  93| 	let items = map.GetAllItems("sec_a");
|  94|  94| 	TS_ASSERT("prim_a" in items)
|  95|    |-	TS_ASSERT("prim_b" in items)
|    |  95|+	TS_ASSERT("prim_b" in items);
|  96|  96| 	TS_ASSERT("prim_c" in items)
|  97|  97| 	let sum = 0;
|  98|  98| 	for (let key in items)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  93|  93| 	let items = map.GetAllItems("sec_a");
|  94|  94| 	TS_ASSERT("prim_a" in items)
|  95|  95| 	TS_ASSERT("prim_b" in items)
|  96|    |-	TS_ASSERT("prim_c" in items)
|    |  96|+	TS_ASSERT("prim_c" in items);
|  97|  97| 	let sum = 0;
|  98|  98| 	for (let key in items)
|  99|  99| 		items[key].forEach(item => sum += item);
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  97|  97| 	let sum = 0;
|  98|  98| 	for (let key in items)
|  99|  99| 		items[key].forEach(item => sum += item);
| 100|    |-	TS_ASSERT(sum == 19)
|    | 100|+	TS_ASSERT(sum == 19);
| 101| 101| 
| 102| 102| 	items = map.GetAllItems("sec_a", true);
| 103| 103| 	sum = 0;
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 104| 104| 	for (let key in items)
| 105| 105| 		items[key].forEach(item => sum += item);
| 106| 106| 	// We're adding more of the first item_c, the value wasn't replaced.
| 107|    |-	TS_ASSERT(sum == 22)
|    | 107|+	TS_ASSERT(sum == 22);
| 108| 108| };
| 109| 109| 
| 110| 110| // Test items, and test that deserialised versions still pass test (i.e. test serialisation).
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 105| 105| 		items[key].forEach(item => sum += item);
| 106| 106| 	// We're adding more of the first item_c, the value wasn't replaced.
| 107| 107| 	TS_ASSERT(sum == 22)
| 108|    |-};
|    | 108|+}
| 109| 109| 
| 110| 110| // Test items, and test that deserialised versions still pass test (i.e. test serialisation).
| 111| 111| let map = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 115| 115| map = new MultiKeyMap();
| 116| 116| let map2 = new MultiKeyMap();
| 117| 117| setup_keys(map);
| 118|    |-map2.Deserialize(map.Serialize())
|    | 118|+map2.Deserialize(map.Serialize());
| 119| 119| test_keys(map2);
| 120| 120| 
| 121| 121| map = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 119| 119| test_keys(map2);
| 120| 120| 
| 121| 121| map = new MultiKeyMap();
| 122|    |-setup_items(map)
|    | 122|+setup_items(map);
| 123| 123| test_items(map);
| 124| 124| map = new MultiKeyMap();
| 125| 125| map2 = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 124| 124| map = new MultiKeyMap();
| 125| 125| map2 = new MultiKeyMap();
| 126| 126| setup_items(map);
| 127|    |-map2.Deserialize(map.Serialize())
|    | 127|+map2.Deserialize(map.Serialize());
| 128| 128| test_items(map2);

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  99| »   »   items[key].forEach(item·=>·sum·+=·item);
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 105| »   »   items[key].forEach(item·=>·sum·+=·item);
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  11| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  16| »   TS_ASSERT(map.items.has("prim_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  17| »   TS_ASSERT(map.items.has("prim_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  18| »   TS_ASSERT(map.items.has("prim_c"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  20| »   TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  21| »   TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  22| »   TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  23| »   TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  24| »   TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  26| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  27| »   TS_ASSERT(map.items.get("prim_a").get("sec_b").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  28| »   TS_ASSERT(map.items.get("prim_b").get("sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  29| »   TS_ASSERT(map.items.get("prim_c").get("sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  31| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  32| »   TS_ASSERT(map.GetItems("prim_a",·"sec_b").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  33| »   TS_ASSERT(map.GetItems("prim_b",·"sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  34| »   TS_ASSERT(map.GetItems("prim_c",·"sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  36| »   TS_ASSERT(map.HasItem("prim_a",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  37| »   TS_ASSERT(map.HasItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  38| »   TS_ASSERT(map.HasItem("prim_a",·"item_c",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  39| »   TS_ASSERT(!map.HasItem("prim_a",·"item_d",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  40| »   TS_ASSERT(map.HasItem("prim_a",·"item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  41| »   TS_ASSERT(!map.HasItem("prim_a",·"item_b",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  42| »   TS_ASSERT(!map.HasItem("prim_a",·"item_c",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  43| »   TS_ASSERT(map.HasItem("prim_b",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  44| »   TS_ASSERT(map.HasItem("prim_c",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  45| »   TS_ASSERT(map.HasAnyItem("item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  46| »   TS_ASSERT(map.HasAnyItem("item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  47| »   TS_ASSERT(!map.HasAnyItem("item_d",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  48| »   TS_ASSERT(!map.HasAnyItem("item_b",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  51| »   map.AddItem("prim_a",·"item_b",·0,·"sec_a")
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  52| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  53| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item·=>·item.ID·==·"item_b")[0].count·==·2)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  54| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  55| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a",·true).length·==·4)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  58| »   TS_ASSERT(!map.AddItem("prim_a",·"item_b",·0,·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  59| »   TS_ASSERT(map.AddItem("prim_a",·"item_b",·0,·"sec_a",·true))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  61| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item·=>·item.ID·==·"item_b")[0].count·==·4)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  64| »   TS_ASSERT(!map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  65| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_b",·"sec_a",·true))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  66| »   TS_ASSERT(!map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  67| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  70| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·2)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  71| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  72| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_c",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  73| »   TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  74| »   TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  75| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  76| »   TS_ASSERT(!map.items.has("prim_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  77| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  77| };
|    | [MAJOR] JSHintBear:
|    | Too many errors. (59% scanned).
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|   6|   6| {
|   7|   7| 	this.items = new Map();
|   8|   8| 	// Keys are referred to as 'primaryKey', 'secondaryKey', 'itemID'.
|   9|    |-};
|    |   9|+}
|  10|  10| 
|  11|  11| MultiKeyMap.prototype.Serialize = function()
|  12|  12| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 155| 155| 	if (!this._exists(primaryKey, secondaryKey))
| 156| 156| 		return [];
| 157| 157| 	return this.items.get(primaryKey).get(secondaryKey);
| 158|    |-}
|    | 158|+};
| 159| 159| 
| 160| 160| /**
| 161| 161|  * @returns a reference to the list of items for that property name and secondaryKey.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 165| 165| 	if (!this._exists(primaryKey, secondaryKey))
| 166| 166| 		this._initItemsIfNeeded(primaryKey, secondaryKey);
| 167| 167| 	return this.items.get(primaryKey).get(secondaryKey);
| 168|    |-}
|    | 168|+};
| 169| 169| 
| 170| 170| MultiKeyMap.prototype._exists = function(primaryKey, secondaryKey)
| 171| 171| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 174| 174| 	if (!this.items.get(primaryKey).get(secondaryKey))
| 175| 175| 		return false;
| 176| 176| 	return true;
| 177|    |-}
|    | 177|+};
| 178| 178| 
| 179| 179| MultiKeyMap.prototype._initItemsIfNeeded = function(primaryKey, secondaryKey)
| 180| 180| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 182| 182| 		this.items.set(primaryKey, new Map());
| 183| 183| 	if (!this.items.get(primaryKey).get(secondaryKey))
| 184| 184| 		this.items.get(primaryKey).set(secondaryKey, []);
| 185|    |-}
|    | 185|+};
| 186| 186| 
| 187| 187| /**
| 188| 188|  * @returns true if the items list changed in such a way that cached values are possibly invalidated.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 124| »   »   this._getItems(primaryKey,·secondaryKey).forEach(item·=>·items·=·items.concat(Array(item.count).fill(item.value)));
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 194| »   let·existingItems·=·items.filter(item·=>·{·return·item.ID·==·itemID;·});
|    | [NORMAL] ESLintBear (no-shadow):
|    | 'item' is already declared in the upper scope.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|   9| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 158| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 168| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 177| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 185| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.
Executing section cli...

Link to build: https://jenkins.wildfiregames.com/job/differential/1330/display/redirect

wraitii updated this revision to Diff 7913.Sun, May 5, 7:24 PM

As I broke components tests earlier I didn't realise this didn't correctly serialise for non-string keys.
It does now and I've added a basic test case for it.

Vulcan added a comment.Sun, May 5, 7:26 PM

Successful build - Chance fights ever on the side of the prudent.

Linter detected issues:
Executing section Source...

source/simulation2/components/tests/test_scripts.h
|   1| /*·Copyright·(C)·2017·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2019" year instead of "2017"

source/lib/file/vfs/vfs_util.cpp
|   1| /*·Copyright·(C)·2015·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2019" year instead of "2015"
Executing section JS...
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|   9|   9| 	map.AddItem("prim_b", "item_a", 0, "sec_a");
|  10|  10| 	map.AddItem("prim_c", "item_a", 0, "sec_a");
|  11|  11| 	map.AddItem("prim_c", "item_a", 0, 5);
|  12|    |-};
|    |  12|+}
|  13|  13| 
|  14|  14| // Check that key-related operations are correct.
|  15|  15| function test_keys(map)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  14|  14| // Check that key-related operations are correct.
|  15|  15| function test_keys(map)
|  16|  16| {
|  17|    |-	TS_ASSERT(map.items.has("prim_a"))
|    |  17|+	TS_ASSERT(map.items.has("prim_a"));
|  18|  18| 	TS_ASSERT(map.items.has("prim_b"))
|  19|  19| 	TS_ASSERT(map.items.has("prim_c"))
|  20|  20| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  15|  15| function test_keys(map)
|  16|  16| {
|  17|  17| 	TS_ASSERT(map.items.has("prim_a"))
|  18|    |-	TS_ASSERT(map.items.has("prim_b"))
|    |  18|+	TS_ASSERT(map.items.has("prim_b"));
|  19|  19| 	TS_ASSERT(map.items.has("prim_c"))
|  20|  20| 
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  16|  16| {
|  17|  17| 	TS_ASSERT(map.items.has("prim_a"))
|  18|  18| 	TS_ASSERT(map.items.has("prim_b"))
|  19|    |-	TS_ASSERT(map.items.has("prim_c"))
|    |  19|+	TS_ASSERT(map.items.has("prim_c"));
|  20|  20| 
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  22|  22| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  18|  18| 	TS_ASSERT(map.items.has("prim_b"))
|  19|  19| 	TS_ASSERT(map.items.has("prim_c"))
|  20|  20| 
|  21|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    |  21|+	TS_ASSERT(map.items.get("prim_a").has("sec_a"));
|  22|  22| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  23|  23| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  19|  19| 	TS_ASSERT(map.items.has("prim_c"))
|  20|  20| 
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  22|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    |  22|+	TS_ASSERT(map.items.get("prim_a").has("sec_b"));
|  23|  23| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  25|  25| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  20|  20| 
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  22|  22| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  23|    |-	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|    |  23|+	TS_ASSERT(!map.items.get("prim_a").has("sec_c"));
|  24|  24| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  25|  25| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  26|  26| 	TS_ASSERT(map.items.get("prim_c").has(5))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  21|  21| 	TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|  22|  22| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  23|  23| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  24|    |-	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    |  24|+	TS_ASSERT(map.items.get("prim_b").has("sec_a"));
|  25|  25| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  26|  26| 	TS_ASSERT(map.items.get("prim_c").has(5))
|  27|  27| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  22|  22| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  23|  23| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  25|    |-	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    |  25|+	TS_ASSERT(map.items.get("prim_c").has("sec_a"));
|  26|  26| 	TS_ASSERT(map.items.get("prim_c").has(5))
|  27|  27| 
|  28|  28| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  23|  23| 	TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|  24|  24| 	TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|  25|  25| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  26|    |-	TS_ASSERT(map.items.get("prim_c").has(5))
|    |  26|+	TS_ASSERT(map.items.get("prim_c").has(5));
|  27|  27| 
|  28|  28| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  29|  29| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  25|  25| 	TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|  26|  26| 	TS_ASSERT(map.items.get("prim_c").has(5))
|  27|  27| 
|  28|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    |  28|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3);
|  29|  29| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  30|  30| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  31|  31| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  26|  26| 	TS_ASSERT(map.items.get("prim_c").has(5))
|  27|  27| 
|  28|  28| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  29|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|    |  29|+	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1);
|  30|  30| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  31|  31| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  32|  32| 	TS_ASSERT(map.items.get("prim_c").get(5).length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  27|  27| 
|  28|  28| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  29|  29| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  30|    |-	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|    |  30|+	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1);
|  31|  31| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  32|  32| 	TS_ASSERT(map.items.get("prim_c").get(5).length == 1)
|  33|  33| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  28|  28| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  29|  29| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  30|  30| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  31|    |-	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|    |  31|+	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1);
|  32|  32| 	TS_ASSERT(map.items.get("prim_c").get(5).length == 1)
|  33|  33| 
|  34|  34| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  29|  29| 	TS_ASSERT(map.items.get("prim_a").get("sec_b").length == 1)
|  30|  30| 	TS_ASSERT(map.items.get("prim_b").get("sec_a").length == 1)
|  31|  31| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  32|    |-	TS_ASSERT(map.items.get("prim_c").get(5).length == 1)
|    |  32|+	TS_ASSERT(map.items.get("prim_c").get(5).length == 1);
|  33|  33| 
|  34|  34| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  35|  35| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  31|  31| 	TS_ASSERT(map.items.get("prim_c").get("sec_a").length == 1)
|  32|  32| 	TS_ASSERT(map.items.get("prim_c").get(5).length == 1)
|  33|  33| 
|  34|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    |  34|+	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3);
|  35|  35| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  36|  36| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  37|  37| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  32|  32| 	TS_ASSERT(map.items.get("prim_c").get(5).length == 1)
|  33|  33| 
|  34|  34| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  35|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|    |  35|+	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1);
|  36|  36| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  37|  37| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  38|  38| 	TS_ASSERT(map.GetItems("prim_c", 5).length == 1)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  33|  33| 
|  34|  34| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  35|  35| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  36|    |-	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|    |  36|+	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1);
|  37|  37| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  38|  38| 	TS_ASSERT(map.GetItems("prim_c", 5).length == 1)
|  39|  39| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  34|  34| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  35|  35| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  36|  36| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  37|    |-	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|    |  37|+	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1);
|  38|  38| 	TS_ASSERT(map.GetItems("prim_c", 5).length == 1)
|  39|  39| 
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  35|  35| 	TS_ASSERT(map.GetItems("prim_a", "sec_b").length == 1)
|  36|  36| 	TS_ASSERT(map.GetItems("prim_b", "sec_a").length == 1)
|  37|  37| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  38|    |-	TS_ASSERT(map.GetItems("prim_c", 5).length == 1)
|    |  38|+	TS_ASSERT(map.GetItems("prim_c", 5).length == 1);
|  39|  39| 
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  41|  41| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  37|  37| 	TS_ASSERT(map.GetItems("prim_c", "sec_a").length == 1)
|  38|  38| 	TS_ASSERT(map.GetItems("prim_c", 5).length == 1)
|  39|  39| 
|  40|    |-	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|    |  40|+	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"));
|  41|  41| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  42|  42| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  43|  43| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  38|  38| 	TS_ASSERT(map.GetItems("prim_c", 5).length == 1)
|  39|  39| 
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  41|    |-	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|    |  41|+	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"));
|  42|  42| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  43|  43| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  39|  39| 
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  41|  41| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  42|    |-	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|    |  42|+	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"));
|  43|  43| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  45|  45| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  40|  40| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_a"))
|  41|  41| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  42|  42| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  43|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|    |  43|+	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"));
|  44|  44| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  45|  45| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  46|  46| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  41|  41| 	TS_ASSERT(map.HasItem("prim_a", "item_b", "sec_a"))
|  42|  42| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  43|  43| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  44|    |-	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|    |  44|+	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"));
|  45|  45| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  46|  46| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  47|  47| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  42|  42| 	TS_ASSERT(map.HasItem("prim_a", "item_c", "sec_a"))
|  43|  43| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  45|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|    |  45|+	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"));
|  46|  46| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  47|  47| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  48|  48| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  43|  43| 	TS_ASSERT(!map.HasItem("prim_a", "item_d", "sec_a"))
|  44|  44| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  45|  45| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  46|    |-	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|    |  46|+	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"));
|  47|  47| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  48|  48| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  49|  49| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  44|  44| 	TS_ASSERT(map.HasItem("prim_a", "item_a", "sec_b"))
|  45|  45| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  46|  46| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  47|    |-	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|    |  47|+	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"));
|  48|  48| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  49|  49| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  50|  50| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  45|  45| 	TS_ASSERT(!map.HasItem("prim_a", "item_b", "sec_b"))
|  46|  46| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  47|  47| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  48|    |-	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|    |  48|+	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"));
|  49|  49| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  50|  50| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  51|  51| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  46|  46| 	TS_ASSERT(!map.HasItem("prim_a", "item_c", "sec_b"))
|  47|  47| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  48|  48| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  49|    |-	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|    |  49|+	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"));
|  50|  50| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  51|  51| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  52|  52| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  47|  47| 	TS_ASSERT(map.HasItem("prim_b", "item_a", "sec_a"))
|  48|  48| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  49|  49| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  50|    |-	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|    |  50|+	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"));
|  51|  51| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  52|  52| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  53|  53| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  48|  48| 	TS_ASSERT(map.HasItem("prim_c", "item_a", "sec_a"))
|  49|  49| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  50|  50| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  51|    |-	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|    |  51|+	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"));
|  52|  52| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  53|  53| 
|  54|  54| 	// Adding the same item increases its count.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  49|  49| 	TS_ASSERT(map.HasAnyItem("item_a", "sec_b"))
|  50|  50| 	TS_ASSERT(map.HasAnyItem("item_b", "sec_a"))
|  51|  51| 	TS_ASSERT(!map.HasAnyItem("item_d", "sec_a"))
|  52|    |-	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|    |  52|+	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"));
|  53|  53| 
|  54|  54| 	// Adding the same item increases its count.
|  55|  55| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  52|  52| 	TS_ASSERT(!map.HasAnyItem("item_b", "sec_b"))
|  53|  53| 
|  54|  54| 	// Adding the same item increases its count.
|  55|    |-	map.AddItem("prim_a", "item_b", 0, "sec_a")
|    |  55|+	map.AddItem("prim_a", "item_b", 0, "sec_a");
|  56|  56| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  57|  57| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  58|  58| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  53|  53| 
|  54|  54| 	// Adding the same item increases its count.
|  55|  55| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  56|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|    |  56|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3);
|  57|  57| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  58|  58| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  59|  59| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  54|  54| 	// Adding the same item increases its count.
|  55|  55| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  56|  56| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  57|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|    |  57|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2);
|  58|  58| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  59|  59| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  60|  60| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  55|  55| 	map.AddItem("prim_a", "item_b", 0, "sec_a")
|  56|  56| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  57|  57| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  58|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|    |  58|+	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3);
|  59|  59| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  60|  60| 
|  61|  61| 	// Adding without stackable doesn't invalidate caches, adding with does.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  56|  56| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 3)
|  57|  57| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 2)
|  58|  58| 	TS_ASSERT(map.GetItems("prim_a", "sec_a").length == 3)
|  59|    |-	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|    |  59|+	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4);
|  60|  60| 
|  61|  61| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  62|  62| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  59|  59| 	TS_ASSERT(map.GetItems("prim_a", "sec_a", true).length == 4)
|  60|  60| 
|  61|  61| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  62|    |-	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|    |  62|+	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"));
|  63|  63| 	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|  64|  64| 
|  65|  65| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  60|  60| 
|  61|  61| 	// Adding without stackable doesn't invalidate caches, adding with does.
|  62|  62| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|  63|    |-	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|    |  63|+	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true));
|  64|  64| 
|  65|  65| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|  66|  66| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  62|  62| 	TS_ASSERT(!map.AddItem("prim_a", "item_b", 0, "sec_a"))
|  63|  63| 	TS_ASSERT(map.AddItem("prim_a", "item_b", 0, "sec_a", true))
|  64|  64| 
|  65|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|    |  65|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4);
|  66|  66| 
|  67|  67| 	// Likewise removing, unless we now reach 0
|  68|  68| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  65|  65| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item => item.ID == "item_b")[0].count == 4)
|  66|  66| 
|  67|  67| 	// Likewise removing, unless we now reach 0
|  68|    |-	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  68|+	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"));
|  69|  69| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  70|  70| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  66|  66| 
|  67|  67| 	// Likewise removing, unless we now reach 0
|  68|  68| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  69|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|    |  69|+	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true));
|  70|  70| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  72|  72| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  67|  67| 	// Likewise removing, unless we now reach 0
|  68|  68| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  69|  69| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  70|    |-	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  70|+	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"));
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  72|  72| 
|  73|  73| 	// Check that cleanup is done
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  68|  68| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  69|  69| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a", true))
|  70|  70| 	TS_ASSERT(!map.RemoveItem("prim_a", "item_b", "sec_a"))
|  71|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|    |  71|+	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"));
|  72|  72| 
|  73|  73| 	// Check that cleanup is done
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  71|  71| 	TS_ASSERT(map.RemoveItem("prim_a", "item_b", "sec_a"))
|  72|  72| 
|  73|  73| 	// Check that cleanup is done
|  74|    |-	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|    |  74|+	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2);
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  76|  76| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  77|  77| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  72|  72| 
|  73|  73| 	// Check that cleanup is done
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  75|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|    |  75|+	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"));
|  76|  76| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  77|  77| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  78|  78| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  73|  73| 	// Check that cleanup is done
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  76|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|    |  76|+	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"));
|  77|  77| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  78|  78| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  79|  79| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  74|  74| 	TS_ASSERT(map.items.get("prim_a").get("sec_a").length == 2)
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  76|  76| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  77|    |-	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    |  77|+	TS_ASSERT(!map.items.get("prim_a").has("sec_a"));
|  78|  78| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  79|  79| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  80|  80| 	TS_ASSERT(!map.items.has("prim_a"))
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  75|  75| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_a"))
|  76|  76| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  77|  77| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  78|    |-	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    |  78|+	TS_ASSERT(map.items.get("prim_a").has("sec_b"));
|  79|  79| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  80|  80| 	TS_ASSERT(!map.items.has("prim_a"))
|  81|  81| };
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  76|  76| 	TS_ASSERT(map.RemoveItem("prim_a", "item_c", "sec_a"))
|  77|  77| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  78|  78| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  79|    |-	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|    |  79|+	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"));
|  80|  80| 	TS_ASSERT(!map.items.has("prim_a"))
|  81|  81| };
|  82|  82| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  77|  77| 	TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|  78|  78| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  79|  79| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  80|    |-	TS_ASSERT(!map.items.has("prim_a"))
|    |  80|+	TS_ASSERT(!map.items.has("prim_a"));
|  81|  81| };
|  82|  82| 
|  83|  83| function setup_items(map)
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  78|  78| 	TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|  79|  79| 	TS_ASSERT(map.RemoveItem("prim_a", "item_a", "sec_b"))
|  80|  80| 	TS_ASSERT(!map.items.has("prim_a"))
|  81|    |-};
|    |  81|+}
|  82|  82| 
|  83|  83| function setup_items(map)
|  84|  84| {
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  89|  89| 	map.AddItem("prim_a", "item_a", 5, "sec_b");
|  90|  90| 	map.AddItem("prim_b", "item_a", 6, "sec_a");
|  91|  91| 	map.AddItem("prim_c", "item_a", 7, "sec_a");
|  92|    |-};
|    |  92|+}
|  93|  93| 
|  94|  94| // Check that items returned are correct.
|  95|  95| function test_items(map)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  95|  95| function test_items(map)
|  96|  96| {
|  97|  97| 	let items = map.GetAllItems("sec_a");
|  98|    |-	TS_ASSERT("prim_a" in items)
|    |  98|+	TS_ASSERT("prim_a" in items);
|  99|  99| 	TS_ASSERT("prim_b" in items)
| 100| 100| 	TS_ASSERT("prim_c" in items)
| 101| 101| 	let sum = 0;
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  96|  96| {
|  97|  97| 	let items = map.GetAllItems("sec_a");
|  98|  98| 	TS_ASSERT("prim_a" in items)
|  99|    |-	TS_ASSERT("prim_b" in items)
|    |  99|+	TS_ASSERT("prim_b" in items);
| 100| 100| 	TS_ASSERT("prim_c" in items)
| 101| 101| 	let sum = 0;
| 102| 102| 	for (let key in items)
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  97|  97| 	let items = map.GetAllItems("sec_a");
|  98|  98| 	TS_ASSERT("prim_a" in items)
|  99|  99| 	TS_ASSERT("prim_b" in items)
| 100|    |-	TS_ASSERT("prim_c" in items)
|    | 100|+	TS_ASSERT("prim_c" in items);
| 101| 101| 	let sum = 0;
| 102| 102| 	for (let key in items)
| 103| 103| 		items[key].forEach(item => sum += item);
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 101| 101| 	let sum = 0;
| 102| 102| 	for (let key in items)
| 103| 103| 		items[key].forEach(item => sum += item);
| 104|    |-	TS_ASSERT(sum == 19)
|    | 104|+	TS_ASSERT(sum == 19);
| 105| 105| 
| 106| 106| 	items = map.GetAllItems("sec_a", true);
| 107| 107| 	sum = 0;
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 108| 108| 	for (let key in items)
| 109| 109| 		items[key].forEach(item => sum += item);
| 110| 110| 	// We're adding more of the first item_c, the value wasn't replaced.
| 111|    |-	TS_ASSERT(sum == 22)
|    | 111|+	TS_ASSERT(sum == 22);
| 112| 112| };
| 113| 113| 
| 114| 114| // Test items, and test that deserialised versions still pass test (i.e. test serialisation).
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 109| 109| 		items[key].forEach(item => sum += item);
| 110| 110| 	// We're adding more of the first item_c, the value wasn't replaced.
| 111| 111| 	TS_ASSERT(sum == 22)
| 112|    |-};
|    | 112|+}
| 113| 113| 
| 114| 114| // Test items, and test that deserialised versions still pass test (i.e. test serialisation).
| 115| 115| let map = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 119| 119| map = new MultiKeyMap();
| 120| 120| let map2 = new MultiKeyMap();
| 121| 121| setup_keys(map);
| 122|    |-map2.Deserialize(map.Serialize())
|    | 122|+map2.Deserialize(map.Serialize());
| 123| 123| test_keys(map2);
| 124| 124| 
| 125| 125| map = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 123| 123| test_keys(map2);
| 124| 124| 
| 125| 125| map = new MultiKeyMap();
| 126|    |-setup_items(map)
|    | 126|+setup_items(map);
| 127| 127| test_items(map);
| 128| 128| map = new MultiKeyMap();
| 129| 129| map2 = new MultiKeyMap();
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 128| 128| map = new MultiKeyMap();
| 129| 129| map2 = new MultiKeyMap();
| 130| 130| setup_items(map);
| 131|    |-map2.Deserialize(map.Serialize())
|    | 131|+map2.Deserialize(map.Serialize());
| 132| 132| test_items(map2);

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 103| »   »   items[key].forEach(item·=>·sum·+=·item);
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
| 109| »   »   items[key].forEach(item·=>·sum·+=·item);
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  12| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  17| »   TS_ASSERT(map.items.has("prim_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  18| »   TS_ASSERT(map.items.has("prim_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  19| »   TS_ASSERT(map.items.has("prim_c"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  21| »   TS_ASSERT(map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  22| »   TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  23| »   TS_ASSERT(!map.items.get("prim_a").has("sec_c"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  24| »   TS_ASSERT(map.items.get("prim_b").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  25| »   TS_ASSERT(map.items.get("prim_c").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  26| »   TS_ASSERT(map.items.get("prim_c").has(5))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  28| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  29| »   TS_ASSERT(map.items.get("prim_a").get("sec_b").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  30| »   TS_ASSERT(map.items.get("prim_b").get("sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  31| »   TS_ASSERT(map.items.get("prim_c").get("sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  32| »   TS_ASSERT(map.items.get("prim_c").get(5).length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  34| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  35| »   TS_ASSERT(map.GetItems("prim_a",·"sec_b").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  36| »   TS_ASSERT(map.GetItems("prim_b",·"sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  37| »   TS_ASSERT(map.GetItems("prim_c",·"sec_a").length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  38| »   TS_ASSERT(map.GetItems("prim_c",·5).length·==·1)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  40| »   TS_ASSERT(map.HasItem("prim_a",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  41| »   TS_ASSERT(map.HasItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  42| »   TS_ASSERT(map.HasItem("prim_a",·"item_c",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  43| »   TS_ASSERT(!map.HasItem("prim_a",·"item_d",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  44| »   TS_ASSERT(map.HasItem("prim_a",·"item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  45| »   TS_ASSERT(!map.HasItem("prim_a",·"item_b",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  46| »   TS_ASSERT(!map.HasItem("prim_a",·"item_c",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  47| »   TS_ASSERT(map.HasItem("prim_b",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  48| »   TS_ASSERT(map.HasItem("prim_c",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  49| »   TS_ASSERT(map.HasAnyItem("item_a",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  50| »   TS_ASSERT(map.HasAnyItem("item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  51| »   TS_ASSERT(!map.HasAnyItem("item_d",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  52| »   TS_ASSERT(!map.HasAnyItem("item_b",·"sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  55| »   map.AddItem("prim_a",·"item_b",·0,·"sec_a")
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  56| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  57| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item·=>·item.ID·==·"item_b")[0].count·==·2)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  58| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a").length·==·3)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  59| »   TS_ASSERT(map.GetItems("prim_a",·"sec_a",·true).length·==·4)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  62| »   TS_ASSERT(!map.AddItem("prim_a",·"item_b",·0,·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  63| »   TS_ASSERT(map.AddItem("prim_a",·"item_b",·0,·"sec_a",·true))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  65| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").filter(item·=>·item.ID·==·"item_b")[0].count·==·4)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  68| »   TS_ASSERT(!map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  69| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_b",·"sec_a",·true))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  70| »   TS_ASSERT(!map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  71| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_b",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  74| »   TS_ASSERT(map.items.get("prim_a").get("sec_a").length·==·2)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  75| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_a",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  76| »   TS_ASSERT(map.RemoveItem("prim_a",·"item_c",·"sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  77| »   TS_ASSERT(!map.items.get("prim_a").has("sec_a"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  78| »   TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/tests/test_MultiKeyMap.js
|  78| »   TS_ASSERT(map.items.get("prim_a").has("sec_b"))
|    | [MAJOR] JSHintBear:
|    | Too many errors. (58% scanned).
|    | [NORMAL] ESLintBear (no-extra-semi):
|    | Unnecessary semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|   6|   6| {
|   7|   7| 	this.items = new Map();
|   8|   8| 	// Keys are referred to as 'primaryKey', 'secondaryKey', 'itemID'.
|   9|    |-};
|    |   9|+}
|  10|  10| 
|  11|  11| MultiKeyMap.prototype.Serialize = function()
|  12|  12| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 157| 157| 	if (!this._exists(primaryKey, secondaryKey))
| 158| 158| 		return [];
| 159| 159| 	return this.items.get(primaryKey).get(secondaryKey);
| 160|    |-}
|    | 160|+};
| 161| 161| 
| 162| 162| /**
| 163| 163|  * @returns a reference to the list of items for that property name and secondaryKey.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 167| 167| 	if (!this._exists(primaryKey, secondaryKey))
| 168| 168| 		this._initItemsIfNeeded(primaryKey, secondaryKey);
| 169| 169| 	return this.items.get(primaryKey).get(secondaryKey);
| 170|    |-}
|    | 170|+};
| 171| 171| 
| 172| 172| MultiKeyMap.prototype._exists = function(primaryKey, secondaryKey)
| 173| 173| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 176| 176| 	if (!this.items.get(primaryKey).has(secondaryKey))
| 177| 177| 		return false;
| 178| 178| 	return true;
| 179|    |-}
|    | 179|+};
| 180| 180| 
| 181| 181| MultiKeyMap.prototype._initItemsIfNeeded = function(primaryKey, secondaryKey)
| 182| 182| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|    |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 184| 184| 		this.items.set(primaryKey, new Map());
| 185| 185| 	if (!this.items.get(primaryKey).get(secondaryKey))
| 186| 186| 		this.items.get(primaryKey).set(secondaryKey, []);
| 187|    |-}
|    | 187|+};
| 188| 188| 
| 189| 189| /**
| 190| 190|  * @returns true if the items list changed in such a way that cached values are possibly invalidated.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 126| »   »   this._getItems(primaryKey,·secondaryKey).forEach(item·=>·items·=·items.concat(Array(item.count).fill(item.value)));
|    | [NORMAL] ESLintBear (no-return-assign):
|    | Arrow function should not return assignment.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 196| »   let·existingItems·=·items.filter(item·=>·{·return·item.ID·==·itemID;·});
|    | [NORMAL] ESLintBear (no-shadow):
|    | 'item' is already declared in the upper scope.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
|   9| };
|    | [NORMAL] JSHintBear:
|    | Unnecessary semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 160| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 170| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 179| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/helpers/MultiKeyMap.js
| 187| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.
Executing section cli...

Link to build: https://jenkins.wildfiregames.com/job/differential/1331/display/redirect

wraitii updated this revision to Diff 8115.Sat, May 25, 12:57 PM

Rebased on top of D1914 and fixed linting issues.

Successful build - Chance fights ever on the side of the prudent.

Linter detected issues:
Executing section Source...

source/simulation2/components/tests/test_scripts.h
|   1| /*·Copyright·(C)·2017·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2019" year instead of "2017"
Executing section JS...
Executing section cli...

Link to build: https://jenkins.wildfiregames.com/job/differential/1477/display/redirect