Fixed some msvc warnings.

Author: 5cript

tests/erase_tests.hpp

@@ -96,7 +96,7 @@ class EraseTests : public ::testing::Test
 
   protected:
     Oracle oracle;
-    lib_interval_tree::interval_tree<OracleInterval<int>> tree;
+    lib_interval_tree::interval_tree<OracleInterval<int>> oracleTree;
     std::default_random_engine gen;
     std::uniform_int_distribution<int> distSmall{-500, 500};
     std::uniform_int_distribution<int> distLarge{-50000, 50000};
@@ -106,59 +106,59 @@ TEST_F(EraseTests, EraseSingleElement)
 {
     auto inserted_interval = interval_type{&oracle, 0, 16};
 
-    tree.insert(std::move(inserted_interval));
+    oracleTree.insert(std::move(inserted_interval));
 
     EXPECT_EQ(oracle.livingInstances, 1);
-    tree.erase(tree.begin());
+    oracleTree.erase(oracleTree.begin());
 
     EXPECT_EQ(oracle.livingInstances, 0);
-    EXPECT_EQ(tree.empty(), true);
-    EXPECT_EQ(tree.size(), 0);
+    EXPECT_EQ(oracleTree.empty(), true);
+    EXPECT_EQ(oracleTree.size(), 0);
 }
 
 TEST_F(EraseTests, ManualClearTest)
 {
     constexpr int amount = 10'000;
 
     for (int i = 0; i != amount; ++i)
-        tree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
+        oracleTree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
 
-    for (auto i = std::begin(tree); i != std::end(tree);)
-        i = tree.erase(i);
+    for (auto i = std::begin(oracleTree); i != std::end(oracleTree);)
+        i = oracleTree.erase(i);
 
     EXPECT_EQ(oracle.livingInstances, 0);
-    EXPECT_EQ(tree.empty(), true);
+    EXPECT_EQ(oracleTree.empty(), true);
 }
 
 TEST_F(EraseTests, ClearTest)
 {
     constexpr int amount = 10'000;
 
     for (int i = 0; i != amount; ++i)
-        tree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
+        oracleTree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
 
-    tree.clear();
+    oracleTree.clear();
 
     EXPECT_EQ(oracle.livingInstances, 0);
-    EXPECT_EQ(tree.empty(), true);
+    EXPECT_EQ(oracleTree.empty(), true);
 }
 
 TEST_F(EraseTests, ExpectedElementIsDeleted)
 {
-    tree.insert(makeSafeOracleInterval(&oracle, 16, 21));
-    tree.insert(makeSafeOracleInterval(&oracle, 8, 9));
-    tree.insert(makeSafeOracleInterval(&oracle, 25, 30));
-    tree.insert(makeSafeOracleInterval(&oracle, 5, 8));
-    tree.insert(makeSafeOracleInterval(&oracle, 15, 23));
-    tree.insert(makeSafeOracleInterval(&oracle, 17, 19));
-    tree.insert(makeSafeOracleInterval(&oracle, 26, 26));
-    tree.insert(makeSafeOracleInterval(&oracle, 0, 3));
-    tree.insert(makeSafeOracleInterval(&oracle, 6, 10));
-    tree.insert(makeSafeOracleInterval(&oracle, 19, 20));
-
-    tree.erase(tree.find(makeSafeOracleInterval(&oracle, 17, 19)));
-    EXPECT_EQ(tree.find(makeSafeOracleInterval(&oracle, 17, 19)), tree.end());
-    EXPECT_EQ(tree.size(), 9);
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 16, 21));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 8, 9));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 25, 30));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 5, 8));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 15, 23));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 17, 19));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 26, 26));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 0, 3));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 6, 10));
+    oracleTree.insert(makeSafeOracleInterval(&oracle, 19, 20));
+
+    oracleTree.erase(oracleTree.find(makeSafeOracleInterval(&oracle, 17, 19)));
+    EXPECT_EQ(oracleTree.find(makeSafeOracleInterval(&oracle, 17, 19)), oracleTree.end());
+    EXPECT_EQ(oracleTree.size(), 9);
 }
 
 TEST_F(EraseTests, RandomEraseTest)
@@ -167,38 +167,38 @@ TEST_F(EraseTests, RandomEraseTest)
     constexpr int deleteAmount = 50;
 
     for (int i = 0; i != amount; ++i)
-        tree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
+        oracleTree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
 
     for (int i = 0; i != deleteAmount; ++i)
     {
         std::uniform_int_distribution<int> dist{0, amount - i - 1};
         auto end = dist(gen);
-        auto iter = tree.begin();
+        auto iter = oracleTree.begin();
         for (int j = 0; j != end; ++j)
             ++iter;
-        tree.erase(iter);
+        oracleTree.erase(iter);
     }
 
     EXPECT_EQ(oracle.livingInstances, amount - deleteAmount);
-    testMaxProperty(tree);
-    testTreeHeightHealth(tree);
+    testMaxProperty(oracleTree);
+    testTreeHeightHealth(oracleTree);
 }
 
 TEST_F(EraseTests, MassiveDeleteEntireTreeWithEraseReturnIterator)
 {
     constexpr int amount = 1000;
 
     for (int i = 0; i != amount; ++i)
-        tree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
+        oracleTree.insert(makeSafeOracleInterval(&oracle, distSmall(gen), distSmall(gen)));
 
-    for (auto iter = tree.begin(); !tree.empty();)
+    for (auto iter = oracleTree.begin(); !oracleTree.empty();)
     {
-        iter = tree.erase(iter);
+        iter = oracleTree.erase(iter);
     }
 
     EXPECT_EQ(oracle.livingInstances, 0);
-    testMaxProperty(tree);
-    testTreeHeightHealth(tree);
+    testMaxProperty(oracleTree);
+    testTreeHeightHealth(oracleTree);
 }
 
 TEST_F(EraseTests, ReturnedIteratorPointsToNextInOrderNode)

tests/hook_tests.hpp

@@ -99,7 +99,7 @@ TEST_F(HookTests, OnBeforeInsertFixupIsCalled)
 {
     bool called = false;
     tree_type<TestHook> tree;
-    tree.on_before_insert_fixup = [&called](void* tree, auto node) {
+    tree.on_before_insert_fixup = [&called](void*, auto) {
         called = true;
     };
 
@@ -112,7 +112,7 @@ TEST_F(HookTests, OnAfterInsertFixupIsCalled)
 {
     bool called = false;
     tree_type<TestHook> tree;
-    tree.on_after_insert_fixup = [&called](void* tree, auto node) {
+    tree.on_after_insert_fixup = [&called](void*, auto) {
         called = true;
     };
 
@@ -125,7 +125,7 @@ TEST_F(HookTests, OnBeforeEraseFixupIsCalled)
 {
     bool called = false;
     tree_type<TestHook> tree;
-    tree.on_before_erase_fixup = [&called](void* tree, auto node, auto node_parent, bool other_is_left_child) {
+    tree.on_before_erase_fixup = [&called](void*, auto, auto, bool) {
         called = true;
     };
 
@@ -149,7 +149,7 @@ TEST_F(HookTests, OnAfterEraseFixupIsCalled)
 {
     bool called = false;
     tree_type<TestHook> tree;
-    tree.on_after_erase_fixup = [&called](void* tree, auto node, auto node_parent, bool other_is_left_child) {
+    tree.on_after_erase_fixup = [&called](void*, auto, auto, bool) {
         called = true;
     };
 
@@ -173,7 +173,7 @@ TEST_F(HookTests, OnBeforeRecalculateMaxIsCalled)
 {
     bool called = false;
     tree_type<TestHook> tree;
-    tree.on_before_recalculate_max = [&called](void* tree, auto node) {
+    tree.on_before_recalculate_max = [&called](void*, auto) {
         called = true;
     };
 
@@ -186,7 +186,7 @@ TEST_F(HookTests, OnAfterRecalculateMaxIsCalled)
 {
     bool called = false;
     tree_type<TestHook> tree;
-    tree.on_after_recalculate_max = [&called](void* tree, auto node) {
+    tree.on_after_recalculate_max = [&called](void*, auto) {
         called = true;
     };
 

tests/test_utility.hpp

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <interval-tree/interval_tree.hpp>
+
+#include <gtest/gtest.h>
+
 #include <functional>
 #include <list>
 #include <cmath>
@@ -38,12 +42,10 @@ void testRedBlackPropertyViolation(TreeT const& tree)
         }
     }
 
-    auto leafCollector = [&](typename TreeT::const_iterator root)
-    {
-        std::list <typename TreeT::const_iterator> leaves{};
-        std::function <void(typename std::list <typename TreeT::const_iterator>::iterator)> recursiveLeafFinder;
-        recursiveLeafFinder = [&](typename std::list <typename TreeT::const_iterator>::iterator self)
-        {
+    auto leafCollector = [&](typename TreeT::const_iterator root) {
+        std::list<typename TreeT::const_iterator> leaves{};
+        std::function<void(typename std::list<typename TreeT::const_iterator>::iterator)> recursiveLeafFinder;
+        recursiveLeafFinder = [&](typename std::list<typename TreeT::const_iterator>::iterator self) {
             if (self->left() != std::end(tree))
             {
                 recursiveLeafFinder(leaves.insert(self, self->left()));
@@ -104,11 +106,12 @@ void testMaxProperty(TreeT const& tree)
 template <typename TreeT>
 void testTreeHeightHealth(TreeT const& tree)
 {
-    int treeSize = tree.size();
+    const auto treeSize = tree.size();
 
     auto maxHeight{0};
     for (auto i = std::begin(tree); i != std::end(tree); ++i)
         maxHeight = std::max(maxHeight, i.node()->height());
 
-    EXPECT_LE(maxHeight, 2 * std::log2(treeSize + 1));
+    const auto calc = 2 * std::log2(static_cast<int>(treeSize) + 1);
+    EXPECT_LE(maxHeight, calc);
 }