add another unit-test

Test/pch.h

@@ -81,7 +81,13 @@
 
 #pragma comment(lib, "ws2_32")
 
+#pragma warning(push)
+#pragma warning(disable: 4800) // Implicit conversion from '...' to bool.Possible information loss
+#pragma warning(disable: 4388) // '...': signed / unsigned mismatch
+#pragma warning(disable: 4866) // compiler may not enforce left - to - right evaluation order for call to '...'
+
 #include "gtest/gtest.h"
+#pragma warning(pop)
 
 #include "six_Test.h"
 #include "sidd_Test.h"

six/modules/c++/cphd/include/cphd/TestDataGenerator.h

@@ -101,6 +101,25 @@ void setUpMetadata(Metadata& metadata);
  *
  *  \throws except::Exception if wideband data is not an accepted type or size
  */
+inline cphd::SignalArrayFormat getSignalArrayFormat(size_t writeDataSize)
+{
+    if (writeDataSize == 2)
+    {
+        return cphd::SignalArrayFormat::CI2;
+    }
+    if (writeDataSize == 4)
+    {
+        return cphd::SignalArrayFormat::CI4;
+    }
+    if (writeDataSize == 8)
+    {
+        return cphd::SignalArrayFormat::CF8;
+    }
+
+    throw except::Exception(Ctxt("Signal format is incorrect size or type"));
+}
+
+
 template<typename T>
 void setUpData(Metadata& metadata,
                const types::RowCol<size_t>& dims,
@@ -128,22 +147,7 @@ void setUpData(Metadata& metadata,
         // Must set the sample type
         else
         {
-            if (sizeof(writeData[0]) == 2)
-            {
-                metadata.data.signalArrayFormat = cphd::SignalArrayFormat::CI2;
-            }
-            else if (sizeof(writeData[0]) == 4)
-            {
-                metadata.data.signalArrayFormat = cphd::SignalArrayFormat::CI4;
-            }
-            else if (sizeof(writeData[0]) == 8)
-            {
-                metadata.data.signalArrayFormat = cphd::SignalArrayFormat::CF8;
-            }
-            else
-            {
-                throw except::Exception(Ctxt("Signal format is incorrect size or type"));
-            }
+            metadata.data.signalArrayFormat = getSignalArrayFormat(sizeof(writeData[0]));
         }
     }
     else

six/modules/c++/cphd/source/Metadata.cpp

@@ -35,24 +35,24 @@ size_t Metadata::getNumChannels() const
     return data.getNumChannels();
 }
 
-size_t Metadata::getNumVectors(size_t channel) const
+size_t Metadata::getNumVectors(size_t channel_) const
 {
-    return data.getNumVectors(channel);
+    return data.getNumVectors(channel_);
 }
 
-size_t Metadata::getNumSamples(size_t channel) const
+size_t Metadata::getNumSamples(size_t channel_) const
 {
-    return data.getNumSamples(channel);
+    return data.getNumSamples(channel_);
 }
 
 size_t Metadata::getNumBytesPerSample() const
 {
     return data.getNumBytesPerSample();
 }
 
-size_t Metadata::getCompressedSignalSize(size_t channel) const
+size_t Metadata::getCompressedSignalSize(size_t channel_) const
 {
-    return data.getCompressedSignalSize(channel);
+    return data.getCompressedSignalSize(channel_);
 }
 
 bool Metadata::isCompressed() const

six/modules/c++/cphd03/unittests/test_cphd_read_unscaled_int.cpp

@@ -67,6 +67,24 @@ std::vector<double> generateScaleFactors(size_t length, bool scale)
     return scaleFactors;
 }
 
+inline cphd::SampleType getSampleType(size_t writeDataSize)
+{
+    //! Must set the sample type
+    if (writeDataSize == 2)
+    {
+        return cphd::SampleType::RE08I_IM08I;
+    }
+    if (writeDataSize == 4)
+    {
+       return cphd::SampleType::RE16I_IM16I;
+    }
+    if (writeDataSize == 8)
+    {
+        return cphd::SampleType::RE32F_IM32F;
+    }
+    throw std::invalid_argument("Unespced writeDataSize");
+}
+
 template<typename T>
 void writeCPHD(const std::string& outPathname, size_t numThreads,
         const types::RowCol<size_t> dims,
@@ -85,18 +103,7 @@ void writeCPHD(const std::string& outPathname, size_t numThreads,
     }
 
     //! Must set the sample type
-    if (sizeof(writeData[0]) == 2)
-    {
-        metadata.data.sampleType = cphd::SampleType::RE08I_IM08I;
-    }
-    else if (sizeof(writeData[0]) == 4)
-    {
-        metadata.data.sampleType = cphd::SampleType::RE16I_IM16I;
-    }
-    else if (sizeof(writeData[0]) == 8)
-    {
-        metadata.data.sampleType = cphd::SampleType::RE32F_IM32F;
-    }
+   metadata.data.sampleType = getSampleType(sizeof(writeData[0]));
 
     //! We must have a radar mode set
     metadata.collectionInformation.radarMode = cphd::RadarModeType::SPOTLIGHT;

six/modules/c++/cphd03/unittests/test_cphd_write.cpp

@@ -352,9 +352,10 @@ void writeCPHD(
 }
 
 
-void runCPHDTest(const std::string& testName,
+void runCPHDTest(const std::string& testName_,
                  cphd03::Metadata& metadata)
 {
+    testName = testName_;
 
     metadata.data.numCPHDChannels = NUM_IMAGES;
 

six/modules/c++/cphd03/unittests/test_vbm.cpp

@@ -33,11 +33,13 @@ static std::string testName;
 
 namespace
 {
-void testVectorParameters(const std::string& testName,
+void testVectorParameters(const std::string& testName_,
                           size_t channel,
                           size_t vector,
                           cphd03::VBM& vbm)
 {
+    testName = testName_;
+
     const double txTime = cphd::getRandom();
     vbm.setTxTime(txTime, channel, vector);