Resharperize

Author: dcwhite

src/Modules/Visualization/Tests/ShowFieldTests.cc

@@ -28,9 +28,6 @@
 
 #include <Testing/ModuleTestBase/ModuleTestBase.h>
 #include <Modules/Visualization/ShowField.h>
-#include <Core/Datatypes/Legacy/Field/Field.h>
-#include <Core/Algorithms/Base/AlgorithmVariableNames.h>
-#include <Core/Utils/Exception.h>
 #include <Core/Logging/Log.h>
 #include <Core/Datatypes/ColorMap.h>
 
@@ -39,40 +36,40 @@ using namespace SCIRun::TestUtils;
 using namespace SCIRun::Core::Datatypes;
 using namespace SCIRun::Dataflow::Networks;
 using namespace SCIRun::Core::Algorithms;
-using namespace SCIRun::Core::Algorithms::Visualization;
-using namespace SCIRun::Core::Algorithms::Visualization::Parameters;
+using namespace Visualization;
+using namespace Parameters;
 using namespace SCIRun::Modules::Visualization;
 using namespace SCIRun::Core;
 using namespace SCIRun;
-using namespace SCIRun::Core::Logging;
+using namespace Logging;
 using ::testing::Values;
 using ::testing::Combine;
 using ::testing::Range;
 
 class ShowFieldScalingTest : public ParameterizedModuleTest<int>
 {
 protected:
-  virtual void SetUp()
+  void SetUp() override
   {
     LogSettings::Instance().setVerbose(false);
-    showField = makeModule("ShowField");
-    showField->setStateDefaults();
-    showField->get_state()->setValue(ShowEdges, false);
+    showField_ = makeModule("ShowField");
+    showField_->setStateDefaults();
+    showField_->get_state()->setValue(ShowEdges, false);
     auto size = GetParam();
-    latVol = CreateEmptyLatVol(size, size, size);
-    stubPortNWithThisData(showField, 0, latVol);
+    latVol_ = CreateEmptyLatVol(size, size, size);
+    stubPortNWithThisData(showField_, 0, latVol_);
     LOG_DEBUG("Setting up ShowField with size {}^3 latvol", size);
   }
 
-  UseRealModuleStateFactory f;
-  ModuleHandle showField;
-  FieldHandle latVol;
+  UseRealModuleStateFactory f_;
+  ModuleHandle showField_;
+  FieldHandle latVol_;
 };
 
 TEST_P(ShowFieldScalingTest, ConstructLatVolGeometry)
 {
   LOG_DEBUG("Start ShowField::execute");
-  showField->execute();
+  showField_->execute();
   LOG_DEBUG("End ShowField::execute");
 }
 
@@ -86,89 +83,85 @@ INSTANTIATE_TEST_CASE_P(
 class ShowFieldStateGeometryNameSynchronizationTest : public ModuleTest
 {
 protected:
-  virtual void SetUp()
+  void SetUp() override
   {
     LogSettings::Instance().setVerbose(false);
-    showField = makeModule("ShowField");
-    showField->setStateDefaults();
-    auto size = 2;
-    latVol = CreateEmptyLatVol(size, size, size);
-    stubPortNWithThisData(showField, 0, latVol);
+    showField_ = makeModule("ShowField");
+    showField_->setStateDefaults();
+    const auto size = 2;
+    latVol_ = CreateEmptyLatVol(size, size, size);
+    stubPortNWithThisData(showField_, 0, latVol_);
   }
 
-  UseRealModuleStateFactory f;
-  ModuleHandle showField;
-  FieldHandle latVol;
+  UseRealModuleStateFactory f_;
+  ModuleHandle showField_;
+  FieldHandle latVol_;
 };
 
 TEST_F(ShowFieldStateGeometryNameSynchronizationTest, GeometryNameSynchronizesWithShowFieldState)
 {
-  ModuleLevelUniqueIDGenerator generator(*showField, "EntireField");
+  const ModuleLevelUniqueIDGenerator generator(*showField_, "EntireField");
   auto hash1 = generator();
-  auto hash2NoChange = generator();
+  const auto hash2NoChange = generator();
   EXPECT_EQ(hash1, hash2NoChange);
 
-  showField->get_state()->setValue(Parameters::CylinderRadius, 2);
+  showField_->get_state()->setValue(Parameters::CylinderRadius, 2);
 
   auto stateChangeShouldBeDifferent = generator();
   EXPECT_NE(hash2NoChange, stateChangeShouldBeDifferent);
   EXPECT_EQ(stateChangeShouldBeDifferent, generator());
 
-  auto size = 3;
-  latVol = CreateEmptyLatVol(size, size, size);
-  stubPortNWithThisData(showField, 0, latVol);
+  const auto size = 3;
+  latVol_ = CreateEmptyLatVol(size, size, size);
+  stubPortNWithThisData(showField_, 0, latVol_);
 
-  auto inputChangeShouldBeDifferent = generator();
+  const auto inputChangeShouldBeDifferent = generator();
   EXPECT_NE(stateChangeShouldBeDifferent, inputChangeShouldBeDifferent);
 
-  stubPortNWithThisData(showField, 1, ColorMapHandle());
-  auto addInputShouldBeDifferent = generator();
+  stubPortNWithThisData(showField_, 1, ColorMapHandle());
+  const auto addInputShouldBeDifferent = generator();
   EXPECT_NE(inputChangeShouldBeDifferent, addInputShouldBeDifferent);
 
   EXPECT_NE(hash1, addInputShouldBeDifferent);
   EXPECT_NE(inputChangeShouldBeDifferent, hash1);
 }
 
-class ShowFieldPreformaceTest : public ModuleTest {};
-TEST_F(ShowFieldPreformaceTest, TestFacePreformace)
+class ShowFieldPerformanceTest : public ModuleTest {};
+
+TEST_F(ShowFieldPerformanceTest, TestFacePerformance)
 {
   LogSettings::Instance().setVerbose(false);
   UseRealModuleStateFactory f;
-  ModuleHandle showField = makeModule("ShowField");
+  auto showField = makeModule("ShowField");
   showField->setStateDefaults();
   auto state = showField->get_state();
   state->setValue(ShowFaces, true);
   state->setValue(ShowEdges, false);
   state->setValue(ShowNodes, false);
   state->setValue(FacesColoring, 1);
 
-  ColorMapHandle colorMap = StandardColorMapFactory::create();
+  const auto colorMap = StandardColorMapFactory::create();
   stubPortNWithThisData(showField, 1, colorMap);
 
-  std::vector<FieldHandle> vectorOfInputData =
+  std::vector<std::pair<FieldHandle, std::string>> vectorOfInputData =
   {
-    CreateEmptyLatVol(64, 64, 64)
+    { CreateEmptyLatVol(64, 64, 64), "64x64x64 LatVol" }
   };
 
-  std::vector<std::string> vectorOfInputDataNames =
-  {
-    "64x64x64 LatVol"
-  };
-
-  const static int NUM_RUNS = 16;
+  const static int NUM_RUNS = 2;
 
-  for(int i = 0; i < vectorOfInputData.size(); ++i)
+  for (const auto& fs : vectorOfInputData)
   {
-
     auto start = std::chrono::steady_clock::now();
-    stubPortNWithThisData(showField, 0, vectorOfInputData[i]);
-    for(int i = 0; i < NUM_RUNS; ++i)
+    stubPortNWithThisData(showField, 0, fs.first);
+    for(int j = 0; j < NUM_RUNS; ++j)
     {
+      std::cout << "Starting execute #" << j << std::endl;
       showField->execute();
-    }
+    } 
     auto end = std::chrono::steady_clock::now();
     auto diff = end - start;
-    std::cout << vectorOfInputDataNames[i] << " : " << std::chrono::duration<double, std::milli>(diff).count()/NUM_RUNS << " ms\n";
+    std::cout << fs.second << " : " << std::chrono::duration<double, std::milli>(diff).count()/NUM_RUNS << " ms\n";
   }
   std::cout << "\n";
 }