Remove std:: namespace of primitive types in tests.

2 files changed, 102 insertions, 102 deletions

diff --git a/test/test-color-map.cpp b/test/test-color-map.cpp
index b40457a..b397b84 100644
--- a/test/test-color-map.cpp
+++ b/test/test-color-map.cpp
@@ -97,7 +97,7 @@ TEST(TestColorMap, InterpolationColorMap)
             EXPECT_EQ(out.size(), 4 * steps);
             for (std::size_t i = 0; i < steps; i++) {
                 double ev = (double)i / (double)(steps-1);
-                std::uint8_t color = (std::uint8_t)std::round(ev * 255.0);
+                uint8_t color = (uint8_t)std::round(ev * 255.0);
                 EXPECT_EQ(out[i * 4 + 0], color);
                 EXPECT_EQ(out[i * 4 + 1], color);
                 EXPECT_EQ(out[i * 4 + 2], color);
@@ -113,10 +113,10 @@ TEST(TestColorMap, InterpolationColorMap)
         EXPECT_EQ(map.Gradient(0).size(), 0);
 
         constexpr std::size_t steps = 9;
-        std::vector<std::uint8_t> exp_r { 0, 128, 255, 128, 0, 0, 0, 0, 0 };
-        std::vector<std::uint8_t> exp_g { 0, 0, 0, 128, 255, 128, 0, 0, 0 };
-        std::vector<std::uint8_t> exp_b { 0, 0, 0, 0, 0, 128, 255, 128, 0 };
-        std::vector<std::uint8_t> exp_a { 255, 128, 0, 0, 0, 0, 0, 128, 255 };
+        std::vector<uint8_t> exp_r { 0, 128, 255, 128, 0, 0, 0, 0, 0 };
+        std::vector<uint8_t> exp_g { 0, 0, 0, 128, 255, 128, 0, 0, 0 };
+        std::vector<uint8_t> exp_b { 0, 0, 0, 0, 0, 128, 255, 128, 0 };
+        std::vector<uint8_t> exp_a { 255, 128, 0, 0, 0, 0, 0, 128, 255 };
 
         { /* 1-length inputs, test simple interpolation */
             for (std::size_t i = 0; i < steps; i++) {
@@ -201,7 +201,7 @@ TEST(TestColorMap, TwoColorMap)
             EXPECT_EQ(out.size(), 4 * steps);
             for (std::size_t i = 0; i < steps; i++) {
                 double ev = (double)i / (double)(steps-1);
-                std::uint8_t color = (std::uint8_t)std::round(ev * 255.0);
+                uint8_t color = (uint8_t)std::round(ev * 255.0);
                 EXPECT_EQ(out[i * 4 + 0], color);
                 EXPECT_EQ(out[i * 4 + 1], color);
                 EXPECT_EQ(out[i * 4 + 2], color);
@@ -220,10 +220,10 @@ TEST(TestColorMap, ThreeColorMap)
         EXPECT_EQ(map.Gradient(0).size(), 0);
 
         constexpr std::size_t steps = 5;
-        std::vector<std::uint8_t> exp_r { 255, 128, 0, 0, 0,  };
-        std::vector<std::uint8_t> exp_g { 0, 128, 255, 128, 0 };
-        std::vector<std::uint8_t> exp_b { 0, 0, 0, 128, 255 };
-        std::vector<std::uint8_t> exp_a { 0, 0, 0, 0, 0 };
+        std::vector<uint8_t> exp_r { 255, 128, 0, 0, 0,  };
+        std::vector<uint8_t> exp_g { 0, 128, 255, 128, 0 };
+        std::vector<uint8_t> exp_b { 0, 0, 0, 128, 255 };
+        std::vector<uint8_t> exp_a { 0, 0, 0, 0, 0 };
 
         { /* 1-length inputs, test simple interpolation */
             for (std::size_t i = 0; i < steps; i++) {
@@ -274,10 +274,10 @@ TEST(TestColorMap, CopyColorMap)
         EXPECT_EQ(map->Gradient(0).size(), 0);
 
         constexpr std::size_t steps = 5;
-        std::vector<std::uint8_t> exp_r { 255, 128, 0, 0, 0,  };
-        std::vector<std::uint8_t> exp_g { 0, 128, 255, 128, 0 };
-        std::vector<std::uint8_t> exp_b { 0, 0, 0, 128, 255 };
-        std::vector<std::uint8_t> exp_a { 0, 0, 0, 0, 0 };
+        std::vector<uint8_t> exp_r { 255, 128, 0, 0, 0,  };
+        std::vector<uint8_t> exp_g { 0, 128, 255, 128, 0 };
+        std::vector<uint8_t> exp_b { 0, 0, 0, 128, 255 };
+        std::vector<uint8_t> exp_a { 0, 0, 0, 0, 0 };
 
         auto out = map->Gradient(steps);
         EXPECT_EQ(out.size(), 4 * steps);
@@ -288,4 +288,4 @@ TEST(TestColorMap, CopyColorMap)
             EXPECT_EQ(out[i * 4 + 3], exp_a[i]);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/test/test-input-parser.cpp b/test/test-input-parser.cpp
index 9b8dc3d..083f40a 100644
--- a/test/test-input-parser.cpp
+++ b/test/test-input-parser.cpp
@@ -27,15 +27,15 @@ TEST(TestInputParser, IsSigned)
 {
     for (bool is_complex : { false, true }) {
         /* direct instantiate */
-        EXPECT_FALSE(IntegerInputParser<std::uint8_t>(1.0, is_complex).IsSigned());
-        EXPECT_FALSE(IntegerInputParser<std::uint16_t>(1.0, is_complex).IsSigned());
-        EXPECT_FALSE(IntegerInputParser<std::uint32_t>(1.0, is_complex).IsSigned());
-        EXPECT_FALSE(IntegerInputParser<std::uint64_t>(1.0, is_complex).IsSigned());
+        EXPECT_FALSE(IntegerInputParser<uint8_t>(1.0, is_complex).IsSigned());
+        EXPECT_FALSE(IntegerInputParser<uint16_t>(1.0, is_complex).IsSigned());
+        EXPECT_FALSE(IntegerInputParser<uint32_t>(1.0, is_complex).IsSigned());
+        EXPECT_FALSE(IntegerInputParser<uint64_t>(1.0, is_complex).IsSigned());
 
-        EXPECT_TRUE(IntegerInputParser<std::int8_t>(1.0, is_complex).IsSigned());
-        EXPECT_TRUE(IntegerInputParser<std::int16_t>(1.0, is_complex).IsSigned());
-        EXPECT_TRUE(IntegerInputParser<std::int32_t>(1.0, is_complex).IsSigned());
-        EXPECT_TRUE(IntegerInputParser<std::int64_t>(1.0, is_complex).IsSigned());
+        EXPECT_TRUE(IntegerInputParser<int8_t>(1.0, is_complex).IsSigned());
+        EXPECT_TRUE(IntegerInputParser<int16_t>(1.0, is_complex).IsSigned());
+        EXPECT_TRUE(IntegerInputParser<int32_t>(1.0, is_complex).IsSigned());
+        EXPECT_TRUE(IntegerInputParser<int64_t>(1.0, is_complex).IsSigned());
 
         EXPECT_TRUE(FloatInputParser<float>(1.0, is_complex).IsSigned());
         EXPECT_TRUE(FloatInputParser<double>(1.0, is_complex).IsSigned());
@@ -60,15 +60,15 @@ TEST(TestInputParser, IsFloatingPoint)
 {
     for (bool is_complex : { false, true }) {
         /* direct instantiate */
-        EXPECT_FALSE(IntegerInputParser<std::uint8_t>(1.0, is_complex).IsFloatingPoint());
-        EXPECT_FALSE(IntegerInputParser<std::uint16_t>(1.0, is_complex).IsFloatingPoint());
-        EXPECT_FALSE(IntegerInputParser<std::uint32_t>(1.0, is_complex).IsFloatingPoint());
-        EXPECT_FALSE(IntegerInputParser<std::uint64_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<uint8_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<uint16_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<uint32_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<uint64_t>(1.0, is_complex).IsFloatingPoint());
 
-        EXPECT_FALSE(IntegerInputParser<std::int8_t>(1.0, is_complex).IsFloatingPoint());
-        EXPECT_FALSE(IntegerInputParser<std::int16_t>(1.0, is_complex).IsFloatingPoint());
-        EXPECT_FALSE(IntegerInputParser<std::int32_t>(1.0, is_complex).IsFloatingPoint());
-        EXPECT_FALSE(IntegerInputParser<std::int64_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<int8_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<int16_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<int32_t>(1.0, is_complex).IsFloatingPoint());
+        EXPECT_FALSE(IntegerInputParser<int64_t>(1.0, is_complex).IsFloatingPoint());
 
         EXPECT_TRUE(FloatInputParser<float>(1.0, is_complex).IsFloatingPoint());
         EXPECT_TRUE(FloatInputParser<double>(1.0, is_complex).IsFloatingPoint());
@@ -93,15 +93,15 @@ TEST(TestInputParser, IsComplex)
 {
     for (bool is_complex : { false, true }) {
         /* direct instantiate */
-        EXPECT_EQ(is_complex, IntegerInputParser<std::uint8_t>(1.0, is_complex).IsComplex());
-        EXPECT_EQ(is_complex, IntegerInputParser<std::uint16_t>(1.0, is_complex).IsComplex());
-        EXPECT_EQ(is_complex, IntegerInputParser<std::uint32_t>(1.0, is_complex).IsComplex());
-        EXPECT_EQ(is_complex, IntegerInputParser<std::uint64_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<uint8_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<uint16_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<uint32_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<uint64_t>(1.0, is_complex).IsComplex());
 
-        EXPECT_EQ(is_complex, IntegerInputParser<std::int8_t>(1.0, is_complex).IsComplex());
-        EXPECT_EQ(is_complex, IntegerInputParser<std::int16_t>(1.0, is_complex).IsComplex());
-        EXPECT_EQ(is_complex, IntegerInputParser<std::int32_t>(1.0, is_complex).IsComplex());
-        EXPECT_EQ(is_complex, IntegerInputParser<std::int64_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<int8_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<int16_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<int32_t>(1.0, is_complex).IsComplex());
+        EXPECT_EQ(is_complex, IntegerInputParser<int64_t>(1.0, is_complex).IsComplex());
 
         EXPECT_EQ(is_complex, FloatInputParser<float>(1.0, is_complex).IsComplex());
         EXPECT_EQ(is_complex, FloatInputParser<double>(1.0, is_complex).IsComplex());
@@ -126,15 +126,15 @@ TEST(TestInputParser, GetDataTypeSize)
 {
     for (bool is_complex : { false, true }) {
         /* direct instantiate */
-        EXPECT_EQ(1 * (is_complex ? 2 : 1), IntegerInputParser<std::uint8_t>(1.0, is_complex).GetDataTypeSize());
-        EXPECT_EQ(2 * (is_complex ? 2 : 1), IntegerInputParser<std::uint16_t>(1.0, is_complex).GetDataTypeSize());
-        EXPECT_EQ(4 * (is_complex ? 2 : 1), IntegerInputParser<std::uint32_t>(1.0, is_complex).GetDataTypeSize());
-        EXPECT_EQ(8 * (is_complex ? 2 : 1), IntegerInputParser<std::uint64_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(1 * (is_complex ? 2 : 1), IntegerInputParser<uint8_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(2 * (is_complex ? 2 : 1), IntegerInputParser<uint16_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(4 * (is_complex ? 2 : 1), IntegerInputParser<uint32_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(8 * (is_complex ? 2 : 1), IntegerInputParser<uint64_t>(1.0, is_complex).GetDataTypeSize());
 
-        EXPECT_EQ(1 * (is_complex ? 2 : 1), IntegerInputParser<std::int8_t>(1.0, is_complex).GetDataTypeSize());
-        EXPECT_EQ(2 * (is_complex ? 2 : 1), IntegerInputParser<std::int16_t>(1.0, is_complex).GetDataTypeSize());
-        EXPECT_EQ(4 * (is_complex ? 2 : 1), IntegerInputParser<std::int32_t>(1.0, is_complex).GetDataTypeSize());
-        EXPECT_EQ(8 * (is_complex ? 2 : 1), IntegerInputParser<std::int64_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(1 * (is_complex ? 2 : 1), IntegerInputParser<int8_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(2 * (is_complex ? 2 : 1), IntegerInputParser<int16_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(4 * (is_complex ? 2 : 1), IntegerInputParser<int32_t>(1.0, is_complex).GetDataTypeSize());
+        EXPECT_EQ(8 * (is_complex ? 2 : 1), IntegerInputParser<int64_t>(1.0, is_complex).GetDataTypeSize());
 
         EXPECT_EQ(4 * (is_complex ? 2 : 1), FloatInputParser<float>(1.0, is_complex).GetDataTypeSize());
         EXPECT_EQ(8 * (is_complex ? 2 : 1), FloatInputParser<double>(1.0, is_complex).GetDataTypeSize());
@@ -160,7 +160,7 @@ TEST(TestInputParser, ParseBlockWrongSize)
     for (bool is_complex : { false, true }) {
         for (auto dt : ALL_DATA_TYPES) {
             auto parser = InputParser::Build(dt, 1.0, is_complex);
-            for (std::size_t bs = 0; bs < 512; bs++) {
+            for (size_t bs = 0; bs < 512; bs++) {
                 if ((bs % parser->GetDataTypeSize()) == 0) {
                     EXPECT_NO_THROW(parser->ParseBlock(std::vector<char>(bs)));
                 } else {
@@ -175,13 +175,13 @@ TEST(TestInputParser, ParseBlockWrongSize)
 using Buffer = std::vector<char>;
 using Result = std::vector<Complex>;
 
-std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t length = 20480)
+std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, size_t length = 20480)
 {
     Buffer buf;
     Result res;
 
     res.resize(length);
-    std::size_t factor = length * (is_complex ? 2 : 1);
+    size_t factor = length * (is_complex ? 2 : 1);
 
     std::random_device rd;
     std::default_random_engine re(rd());
@@ -190,17 +190,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kSignedInt8:
             {
                 buf.resize(factor * 1);
-                std::uniform_int_distribution<std::int8_t> ud;
-                auto mem = (std::int8_t *) buf.data();
-                for (std::size_t i = 0; i < length; i++) {
+                std::uniform_int_distribution<int8_t> ud;
+                auto mem = (int8_t *) buf.data();
+                for (size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::int8_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::int8_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<int8_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<int8_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::int8_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<int8_t>::max());
                     }
                 }
             }
@@ -209,17 +209,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kUnsignedInt8:
             {
                 buf.resize(factor * 1);
-                std::uniform_int_distribution<std::uint8_t> ud;
-                auto mem = (std::uint8_t *) buf.data();
-                for (std::size_t i = 0; i < length; i++) {
+                std::uniform_int_distribution<uint8_t> ud;
+                auto mem = (uint8_t *) buf.data();
+                for (size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::uint8_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::uint8_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<uint8_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<uint8_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::uint8_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<uint8_t>::max());
                     }
                 }
             }
@@ -228,17 +228,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kSignedInt16:
             {
                 buf.resize(factor * 2);
-                std::uniform_int_distribution<std::int16_t> ud;
-                auto mem = (std::int16_t *) buf.data();
+                std::uniform_int_distribution<int16_t> ud;
+                auto mem = (int16_t *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::int16_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::int16_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<int16_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<int16_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::int16_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<int16_t>::max());
                     }
                 }
             }
@@ -247,17 +247,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kUnsignedInt16:
             {
                 buf.resize(factor * 2);
-                std::uniform_int_distribution<std::uint16_t> ud;
-                auto mem = (std::uint16_t *) buf.data();
+                std::uniform_int_distribution<uint16_t> ud;
+                auto mem = (uint16_t *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::uint16_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::uint16_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<uint16_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<uint16_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::uint16_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<uint16_t>::max());
                     }
                 }
             }
@@ -266,17 +266,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kSignedInt32:
             {
                 buf.resize(factor * 4);
-                std::uniform_int_distribution<std::int32_t> ud;
-                auto mem = (std::int32_t *) buf.data();
+                std::uniform_int_distribution<int32_t> ud;
+                auto mem = (int32_t *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::int32_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::int32_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<int32_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<int32_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::int32_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<int32_t>::max());
                     }
                 }
             }
@@ -285,17 +285,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kUnsignedInt32:
             {
                 buf.resize(factor * 4);
-                std::uniform_int_distribution<std::uint32_t> ud;
-                auto mem = (std::uint32_t *) buf.data();
+                std::uniform_int_distribution<uint32_t> ud;
+                auto mem = (uint32_t *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::uint32_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::uint32_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<uint32_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<uint32_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::uint32_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<uint32_t>::max());
                     }
                 }
             }
@@ -304,17 +304,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kSignedInt64:
             {
                 buf.resize(factor * 8);
-                std::uniform_int_distribution<std::int64_t> ud;
-                auto mem = (std::int64_t *) buf.data();
+                std::uniform_int_distribution<int64_t> ud;
+                auto mem = (int64_t *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::int64_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::int64_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<int64_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<int64_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::int64_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<int64_t>::max());
                     }
                 }
             }
@@ -323,17 +323,17 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kUnsignedInt64:
             {
                 buf.resize(factor * 8);
-                std::uniform_int_distribution<std::uint64_t> ud;
-                auto mem = (std::uint64_t *) buf.data();
+                std::uniform_int_distribution<uint64_t> ud;
+                auto mem = (uint64_t *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
                         mem[i*2+0] = ud(re);
                         mem[i*2+1] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<std::uint64_t>::max(),
-                                                      (double)mem[i*2+1] / (double)std::numeric_limits<std::uint64_t>::max());
+                        res[i] = std::complex<double>((double)mem[i*2+0] / (double)std::numeric_limits<uint64_t>::max(),
+                                                      (double)mem[i*2+1] / (double)std::numeric_limits<uint64_t>::max());
                     } else {
                         mem[i] = ud(re);
-                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<std::uint64_t>::max());
+                        res[i] = std::complex<double>((double)mem[i] / (double)std::numeric_limits<uint64_t>::max());
                     }
                 }
             }
@@ -342,15 +342,15 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kFloat32:
             {
                 buf.resize(factor * 4);
-                std::uniform_int_distribution<std::int64_t> ud;
+                std::uniform_int_distribution<int64_t> ud;
                 auto mem = (float *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
-                        mem[i*2+0] = (float)ud(re) / (float)std::numeric_limits<std::uint64_t>::max();
-                        mem[i*2+1] = (float)ud(re) / (float)std::numeric_limits<std::uint64_t>::max();
+                        mem[i*2+0] = (float)ud(re) / (float)std::numeric_limits<uint64_t>::max();
+                        mem[i*2+1] = (float)ud(re) / (float)std::numeric_limits<uint64_t>::max();
                         res[i] = std::complex<double>(mem[i*2+0], mem[i*2+1]);
                     } else {
-                        mem[i] = (float)ud(re) / (float)std::numeric_limits<std::uint64_t>::max();
+                        mem[i] = (float)ud(re) / (float)std::numeric_limits<uint64_t>::max();
                         res[i] = std::complex<double>(mem[i]);
                     }
                 }
@@ -360,15 +360,15 @@ std::tuple<Buffer, Result> make_test(DataType dt, bool is_complex, std::size_t l
         case DataType::kFloat64:
             {
                 buf.resize(factor * 8);
-                std::uniform_int_distribution<std::int64_t> ud;
+                std::uniform_int_distribution<int64_t> ud;
                 auto mem = (double *) buf.data();
                 for (std::size_t i = 0; i < length; i++) {
                     if (is_complex) {
-                        mem[i*2+0] = (double)ud(re) / (double)std::numeric_limits<std::uint64_t>::max();
-                        mem[i*2+1] = (double)ud(re) / (double)std::numeric_limits<std::uint64_t>::max();
+                        mem[i*2+0] = (double)ud(re) / (double)std::numeric_limits<uint64_t>::max();
+                        mem[i*2+1] = (double)ud(re) / (double)std::numeric_limits<uint64_t>::max();
                         res[i] = std::complex<double>(mem[i*2+0], mem[i*2+1]);
                     } else {
-                        mem[i] = (double)ud(re) / (double)std::numeric_limits<std::uint64_t>::max();
+                        mem[i] = (double)ud(re) / (double)std::numeric_limits<uint64_t>::max();
                         res[i] = std::complex<double>(mem[i]);
                     }
                 }
@@ -470,8 +470,8 @@ TEST(TestInputParser, RemoveValues)
                 std::vector<Complex> result;
                 EXPECT_NO_THROW(parser->RemoveValues(i));
                 EXPECT_NO_THROW(result = parser->PeekValues(1000000));
-                EXPECT_EQ(result.size(), std::max<std::int64_t>(parsed_count - i, 0));
+                EXPECT_EQ(result.size(), std::max<int64_t>(parsed_count - i, 0));
             }
         }
     }
-}
\ No newline at end of file
+}