EXSWCPHIPT-134 - Negative tests for hipMalloc3DArray and hipArray3DCreate (#2784)

catch/unit/memory/hipArray3DCreate.cc

@@ -17,8 +17,10 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
+#include <limits>
 #include "DriverContext.hh"
 #include "hipArrayCommon.hh"
+#include "hip_test_common.hh"
 
 namespace {
 void checkArrayIsExpected(const hiparray array, const HIP_ARRAY3D_DESCRIPTOR& expected_desc) {
@@ -38,6 +40,11 @@ void checkArrayIsExpected(const hiparray array, const HIP_ARRAY3D_DESCRIPTOR& ex
   REQUIRE(queried_desc.Flags == expected_desc.Flags);
 #endif
 }
+
+void testInvalidDescription(HIP_ARRAY3D_DESCRIPTOR desc) {
+  hiparray array;
+  HIP_CHECK_ERROR(hipArray3DCreate(&array, &desc), hipErrorInvalidValue);
+}
 }  // namespace
 
 TEMPLATE_TEST_CASE("Unit_hipArray3DCreate_happy", "", char, uchar2, uint2, int4, short4, float,
@@ -45,7 +52,6 @@ TEMPLATE_TEST_CASE("Unit_hipArray3DCreate_happy", "", char, uchar2, uint2, int4,
   using vec_info = vector_info<TestType>;
   DriverContext ctx;
 
-  hiparray array;
   HIP_ARRAY3D_DESCRIPTOR desc{};
   desc.Format = vec_info::format;
   desc.NumChannels = vec_info::size;
@@ -70,6 +76,7 @@ TEMPLATE_TEST_CASE("Unit_hipArray3DCreate_happy", "", char, uchar2, uint2, int4,
 
     CAPTURE(desc.Width, desc.Height, desc.Depth);
 
+    hiparray array;
     HIP_CHECK(hipArray3DCreate(&array, &desc));
     checkArrayIsExpected(array, desc);
     HIP_CHECK(hipArrayDestroy(array));
@@ -164,3 +171,151 @@ TEMPLATE_TEST_CASE("Unit_hipArray3DCreate_MaxTexture", "", int, uint4, short, us
     HIP_CHECK_ERROR(hipArray3DCreate(&array, &desc), hipErrorInvalidValue);
   }
 }
+
+#if HT_NVIDIA
+constexpr std::array<unsigned int, 9> validFlags{
+    0,
+    hipArraySurfaceLoadStore,
+    hipArrayLayered,
+    hipArrayLayered | hipArraySurfaceLoadStore,
+    hipArrayCubemap,
+    hipArrayCubemap | hipArrayLayered,
+    hipArrayCubemap | hipArraySurfaceLoadStore,
+    hipArrayCubemap | hipArrayLayered | hipArraySurfaceLoadStore,
+    hipArrayTextureGather};
+#else
+constexpr std::array<unsigned int, 5> validFlags{
+    0, hipArrayCubemap, hipArrayCubemap | hipArrayLayered,
+    hipArrayCubemap | hipArraySurfaceLoadStore,
+    hipArrayCubemap | hipArrayLayered | hipArraySurfaceLoadStore};
+#endif
+
+constexpr HIP_ARRAY3D_DESCRIPTOR defaultDescriptor(unsigned int flags, size_t size) {
+  HIP_ARRAY3D_DESCRIPTOR desc{};
+  desc.Format = HIP_AD_FORMAT_FLOAT;
+  desc.NumChannels = 4;
+  desc.Flags = flags;
+  desc.Width = size;
+  desc.Height = size;
+  desc.Depth = size;
+
+#if HT_NVIDIA
+  if (flags == CUDA_ARRAY3D_TEXTURE_GATHER) {
+    desc.Depth = 0;
+  }
+#endif
+  return desc;
+}
+
+// Providing the array pointer as nullptr should return an error
+TEST_CASE("Unit_hipArray3DCreate_Negative_NullArrayPtr") {
+  auto desc = defaultDescriptor(0, 64);
+
+  DriverContext ctx;
+  HIP_CHECK_ERROR(hipArray3DCreate(nullptr, &desc), hipErrorInvalidValue);
+}
+
+// Providing the description pointer as nullptr should return an error
+TEST_CASE("Unit_hipArray3DCreate_Negative_NullDescPtr") {
+#if HT_AMD
+  HipTest::HIP_SKIP_TEST("EXSWCPHIPT-130");
+  return;
+#endif
+
+  DriverContext ctx;
+  hiparray array;
+  HIP_CHECK_ERROR(hipArray3DCreate(&array, nullptr), hipErrorInvalidValue);
+}
+
+
+// Zero width arrays are not allowed
+TEST_CASE("Unit_hipArray3DCreate_Negative_ZeroWidth") {
+  DriverContext ctx;
+
+  unsigned int flags = GENERATE(from_range(std::begin(validFlags), std::end(validFlags)));
+  auto desc = defaultDescriptor(flags, 6);
+  desc.Width = 0;
+  CAPTURE(desc.Flags);
+
+  testInvalidDescription(desc);
+}
+
+// Zero height arrays are only allowed for 1D arrays and layered arrays
+TEST_CASE("Unit_hipArray3DCreate_Negative_ZeroHeight") {
+  DriverContext ctx;
+
+  unsigned int flags = GENERATE(from_range(std::begin(validFlags), std::end(validFlags)));
+  auto desc = defaultDescriptor(flags, 6);
+#if HT_NVIDIA
+  std::array<unsigned int, 2> exceptions{CUDA_ARRAY3D_LAYERED,
+                                         CUDA_ARRAY3D_LAYERED | CUDA_ARRAY3D_SURFACE_LDST};
+#else
+  std::array<unsigned int, 0> exceptions{};
+#endif
+  desc.Height = 0;
+
+  if (std::find(std::begin(exceptions), std::end(exceptions), desc.Flags) == std::end(exceptions)) {
+    // flag is not in list of exceptions
+    testInvalidDescription(desc);
+  }
+}
+
+// Arrays must be created with a valid data format
+TEST_CASE("Unit_hipArray3DCreate_Negative_InvalidFormat") {
+  DriverContext ctx;
+
+  unsigned int flags = GENERATE(from_range(std::begin(validFlags), std::end(validFlags)));
+  auto desc = defaultDescriptor(flags, 6);
+
+  desc.Format = static_cast<hipArray_Format>(0xDEADBEEF);
+  REQUIRE(std::find(std::begin(driverFormats), std::end(driverFormats), desc.Format) ==
+          std::end(driverFormats));
+
+  testInvalidDescription(desc);
+}
+
+// An array must have either 1,2, or 4 channels
+TEST_CASE("Unit_hipArray3DCreate_Negative_NumChannels") {
+  DriverContext ctx;
+  unsigned int flags = GENERATE(from_range(std::begin(validFlags), std::end(validFlags)));
+  auto desc = defaultDescriptor(flags, 6);
+  desc.NumChannels = GENERATE(0, 3, 5);
+
+  testInvalidDescription(desc);
+}
+
+// Using invalid flags should result in an error
+TEST_CASE("Unit_hipArray3DCreate_Negative_InvalidFlags") {
+  DriverContext ctx;
+
+  // FIXME: use the same flags for both tests when the values exist for hip
+#if HT_NVIDIA
+  unsigned int flags =
+      GENERATE(0xDEADBEEF, CUDA_ARRAY3D_TEXTURE_GATHER | CUDA_ARRAY3D_SURFACE_LDST,
+               CUDA_ARRAY3D_TEXTURE_GATHER | CUDA_ARRAY3D_CUBEMAP,
+               CUDA_ARRAY3D_TEXTURE_GATHER | CUDA_ARRAY3D_SURFACE_LDST | CUDA_ARRAY3D_CUBEMAP);
+#else
+  unsigned int flags = 0xDEADBEEF;
+#endif
+
+  CAPTURE(flags);
+
+  auto desc = defaultDescriptor(flags, 6);
+
+
+  REQUIRE(std::find(std::begin(validFlags), std::end(validFlags), desc.Flags) ==
+          std::end(validFlags));
+
+  testInvalidDescription(desc);
+}
+
+
+// hipArray3DCreate should handle the max numeric value gracefully.
+TEST_CASE("Unit_hipArray3DCreate_Negative_NumericLimit") {
+  DriverContext ctx;
+
+  unsigned int flags = GENERATE(from_range(std::begin(validFlags), std::end(validFlags)));
+  auto desc = defaultDescriptor(flags, std::numeric_limits<size_t>::max());
+
+  testInvalidDescription(desc);
+}