Rename s8rng/s32rng -> i8rng/i32rng

PiperOrigin-RevId: 324746732
diff --git a/test/convolution-operator-tester.h b/test/convolution-operator-tester.h
index e6ecb67..8595a66 100644
--- a/test/convolution-operator-tester.h
+++ b/test/convolution-operator-tester.h
@@ -509,7 +509,7 @@
   void TestNHWCxQU8() const {
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<uint8_t> input(XNN_EXTRA_BYTES / sizeof(uint8_t) +
@@ -526,7 +526,7 @@
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       std::generate(input.begin(), input.end(), std::ref(u8rng));
       std::generate(kernel.begin(), kernel.end(), std::ref(u8rng));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(output.begin(), output.end(), 0xA5);
 
       // Compute reference results, without renormalization.
@@ -1187,7 +1187,7 @@
 
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<uint8_t> input(XNN_EXTRA_BYTES / sizeof(uint8_t) + std::max(
@@ -1209,7 +1209,7 @@
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       std::generate(input.begin(), input.end(), std::ref(u8rng));
       std::generate(kernel.begin(), kernel.end(), std::ref(u8rng));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(output.begin(), output.end(), 0xA5);
 
       // Compute reference results, without renormalization.
diff --git a/test/deconvolution-operator-tester.h b/test/deconvolution-operator-tester.h
index 49049c5..9e9212b 100644
--- a/test/deconvolution-operator-tester.h
+++ b/test/deconvolution-operator-tester.h
@@ -486,7 +486,7 @@
   void TestQU8() const {
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<uint8_t> input(XNN_EXTRA_BYTES / sizeof(uint8_t) +
@@ -503,7 +503,7 @@
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       std::generate(input.begin(), input.end(), std::ref(u8rng));
       std::generate(kernel.begin(), kernel.end(), std::ref(u8rng));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(output.begin(), output.end(), 0xA5);
 
       // Compute reference results, without renormalization.
@@ -759,7 +759,7 @@
   void TestSetupQU8() const {
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<uint8_t> input(XNN_EXTRA_BYTES / sizeof(uint8_t) + std::max(
@@ -781,7 +781,7 @@
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       std::generate(input.begin(), input.end(), std::ref(u8rng));
       std::generate(kernel.begin(), kernel.end(), std::ref(u8rng));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(output.begin(), output.end(), 0xA5);
 
       // Compute reference results, without renormalization.
diff --git a/test/dwconv-microkernel-tester.h b/test/dwconv-microkernel-tester.h
index bb2af11..42bff16 100644
--- a/test/dwconv-microkernel-tester.h
+++ b/test/dwconv-microkernel-tester.h
@@ -173,7 +173,7 @@
   void Test(xnn_qu8_dwconv_minmax_unipass_ukernel_function dwconv_minmax, Variant variant = Variant::Native) const {
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<const uint8_t*> indirection((width() - 1) * step() + kr());
@@ -193,7 +193,7 @@
       do {
         std::generate(kernel.begin(), kernel.end(), std::ref(u8rng));
       } while (kernel.size() > 1 && *std::max_element(kernel.cbegin(), kernel.cend()) == *std::min_element(kernel.cbegin(), kernel.cend()));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(zero.begin(), zero.end(), input_zero_point());
       std::fill(output.begin(), output.end(), 0xA5);
 
diff --git a/test/fully-connected-operator-tester.h b/test/fully-connected-operator-tester.h
index 64f9d39..648de5d 100644
--- a/test/fully-connected-operator-tester.h
+++ b/test/fully-connected-operator-tester.h
@@ -132,7 +132,7 @@
   void TestQU8() const {
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<uint8_t> input(XNN_EXTRA_BYTES / sizeof(uint8_t) +
@@ -149,7 +149,7 @@
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       std::generate(input.begin(), input.end(), std::ref(u8rng));
       std::generate(kernel.begin(), kernel.end(), std::ref(u8rng));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(output.begin(), output.end(), 0xA5);
 
       // Compute reference results, without renormalization.
diff --git a/test/gemm-microkernel-tester.h b/test/gemm-microkernel-tester.h
index af94335..24a8f8d 100644
--- a/test/gemm-microkernel-tester.h
+++ b/test/gemm-microkernel-tester.h
@@ -217,7 +217,7 @@
 
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<uint8_t> a((m() - 1) * a_stride() + k() + XNN_EXTRA_BYTES / sizeof(uint8_t));
@@ -235,7 +235,7 @@
       do {
         std::generate(b.begin(), b.end(), std::ref(u8rng));
       } while (b.size() > 1 && *std::max_element(b.cbegin(), b.cend()) == *std::min_element(b.cbegin(), b.cend()));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(c.begin(), c.end(), 0xA5);
 
       std::fill(packed_w.begin(), packed_w.end(), b_zero_point());
@@ -311,7 +311,7 @@
 
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
     auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), rng);
 
     std::vector<uint8_t> a((mr() - 1) * a_stride() + k() + XNN_EXTRA_BYTES / sizeof(uint8_t));
@@ -333,7 +333,7 @@
       do {
         std::generate(b.begin(), b.end(), std::ref(u8rng));
       } while (b.size() > 1 && *std::max_element(b.cbegin(), b.cend()) == *std::min_element(b.cbegin(), b.cend()));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(c.begin(), c.end(), 0xA5);
 
       std::fill(packed_w.begin(), packed_w.end(), b_zero_point());
@@ -438,8 +438,8 @@
 
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
-    auto s8rng = std::bind(
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i8rng = std::bind(
       std::uniform_int_distribution<int32_t>(std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max()), rng);
 
     std::vector<int8_t> a((m() - 1) * a_stride() + k() + XNN_EXTRA_BYTES / sizeof(int8_t));
@@ -452,12 +452,12 @@
 
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       do {
-        std::generate(a.begin(), a.end(), std::ref(s8rng));
+        std::generate(a.begin(), a.end(), std::ref(i8rng));
       } while (a.size() > 1 && *std::max_element(a.cbegin(), a.cend()) == *std::min_element(a.cbegin(), a.cend()));
       do {
-        std::generate(b.begin(), b.end(), std::ref(s8rng));
+        std::generate(b.begin(), b.end(), std::ref(i8rng));
       } while (b.size() > 1 && *std::max_element(b.cbegin(), b.cend()) == *std::min_element(b.cbegin(), b.cend()));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(c.begin(), c.end(), 0xA5);
 
       std::fill(packed_w.begin(), packed_w.end(), 0);
@@ -531,8 +531,8 @@
 
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
-    auto s8rng = std::bind(
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i8rng = std::bind(
       std::uniform_int_distribution<int32_t>(std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max()), rng);
 
     std::vector<int8_t> a((m() - 1) * a_stride() + k() + XNN_EXTRA_BYTES / sizeof(int8_t));
@@ -545,12 +545,12 @@
 
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       do {
-        std::generate(a.begin(), a.end(), std::ref(s8rng));
+        std::generate(a.begin(), a.end(), std::ref(i8rng));
       } while (a.size() > 1 && *std::max_element(a.cbegin(), a.cend()) == *std::min_element(a.cbegin(), a.cend()));
       do {
-        std::generate(b.begin(), b.end(), std::ref(s8rng));
+        std::generate(b.begin(), b.end(), std::ref(i8rng));
       } while (b.size() > 1 && *std::max_element(b.cbegin(), b.cend()) == *std::min_element(b.cbegin(), b.cend()));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(c.begin(), c.end(), 0xA5);
 
       std::fill(packed_w.begin(), packed_w.end(), 0);
@@ -624,8 +624,8 @@
 
     std::random_device random_device;
     auto rng = std::mt19937(random_device());
-    auto s32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
-    auto s8rng = std::bind(
+    auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), rng);
+    auto i8rng = std::bind(
       std::uniform_int_distribution<int32_t>(std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max()), rng);
 
     std::vector<int8_t> a((mr() - 1) * a_stride() + k() + XNN_EXTRA_BYTES / sizeof(uint8_t));
@@ -642,12 +642,12 @@
 
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
       do {
-        std::generate(a.begin(), a.end(), std::ref(s8rng));
+        std::generate(a.begin(), a.end(), std::ref(i8rng));
       } while (a.size() > 1 && *std::max_element(a.cbegin(), a.cend()) == *std::min_element(a.cbegin(), a.cend()));
       do {
-        std::generate(b.begin(), b.end(), std::ref(s8rng));
+        std::generate(b.begin(), b.end(), std::ref(i8rng));
       } while (b.size() > 1 && *std::max_element(b.cbegin(), b.cend()) == *std::min_element(b.cbegin(), b.cend()));
-      std::generate(bias.begin(), bias.end(), std::ref(s32rng));
+      std::generate(bias.begin(), bias.end(), std::ref(i32rng));
       std::fill(c.begin(), c.end(), 0xA5);
 
       std::fill(packed_w.begin(), packed_w.end(), 0);
diff --git a/test/requantization-tester.h b/test/requantization-tester.h
index c19ec0f..777099b 100644
--- a/test/requantization-tester.h
+++ b/test/requantization-tester.h
@@ -541,7 +541,7 @@
     std::random_device random_device;
     std::mt19937 rng(random_device());
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
-      auto s8rng = std::bind(
+      auto i8rng = std::bind(
         std::uniform_int_distribution<int32_t>(std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max()), std::ref(rng));
 
       std::vector<int32_t> inputs(4096);
@@ -550,7 +550,7 @@
       std::uniform_real_distribution<float> scale_distribution(0x1.000000p-23f, 0x1.FFFFFEp-1f);
       const float scale = scale_distribution(rng);
       for (size_t i = 0; i < inputs.size(); i++) {
-        const int8_t approximate_output = std::min(std::max(int8_t(s8rng()), int8_t(qmin())), int8_t(qmax()));
+        const int8_t approximate_output = std::min(std::max(int8_t(i8rng()), int8_t(qmin())), int8_t(qmax()));
         const int32_t input = int32_t(double(approximate_output) / double(scale));
         inputs[i] = input;
       }
@@ -629,7 +629,7 @@
     std::random_device random_device;
     std::mt19937 rng(random_device());
     for (size_t iteration = 0; iteration < iterations(); iteration++) {
-      auto s8rng = std::bind(
+      auto i8rng = std::bind(
         std::uniform_int_distribution<int32_t>(std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max()), std::ref(rng));
 
       std::vector<int32_t> inputs(4096);
@@ -638,7 +638,7 @@
       std::uniform_real_distribution<float> scale_distribution(0x1.000000p-23f, 0x1.FFFFFEp-1f);
       const float scale = scale_distribution(rng);
       for (size_t i = 0; i < inputs.size(); i++) {
-        const int8_t approximate_output = std::min(std::max(int8_t(s8rng()), int8_t(qmin())), int8_t(qmax()));
+        const int8_t approximate_output = std::min(std::max(int8_t(i8rng()), int8_t(qmin())), int8_t(qmax()));
         const int32_t input = int32_t(double(approximate_output) / double(scale));
         inputs[i] = input;
       }