mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 14:09:03 +00:00
504 lines
20 KiB
C++
504 lines
20 KiB
C++
//
|
|
// Copyright (c) 2024 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "testBase.h"
|
|
#include "harness/typeWrappers.h"
|
|
|
|
#include <vector>
|
|
|
|
REGISTER_TEST(negative_create_command_queue)
|
|
{
|
|
cl_int err = 0;
|
|
clCreateCommandQueue(nullptr, device, 0, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_CONTEXT,
|
|
"clCreateCommandQueue should return CL_INVALID_CONTEXT when: \"context "
|
|
"is not a valid context\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
clCreateCommandQueue(context, nullptr, 0, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_DEVICE,
|
|
"clCreateCommandQueue should return CL_INVALID_DEVICE when: \"device "
|
|
"is not a valid device\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
cl_device_id different_device = GetOpposingDevice(device);
|
|
if (different_device && device != different_device)
|
|
{
|
|
clCreateCommandQueue(context, different_device, 0, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_DEVICE,
|
|
"clCreateCommandQueue should return CL_INVALID_DEVICE when: "
|
|
"\"device is not associated with context\"",
|
|
TEST_FAIL);
|
|
}
|
|
|
|
cl_queue_properties invalid_property{ static_cast<cl_queue_properties>(
|
|
-1) };
|
|
clCreateCommandQueue(context, device, invalid_property, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_VALUE,
|
|
"clCreateCommandQueue should return CL_INVALID_VALUE when: \"values "
|
|
"specified in properties are not valid\"",
|
|
TEST_FAIL);
|
|
|
|
cl_command_queue_properties device_queue_properties = 0;
|
|
err = clGetDeviceInfo(device, CL_DEVICE_QUEUE_PROPERTIES,
|
|
sizeof(device_queue_properties),
|
|
&device_queue_properties, nullptr);
|
|
test_error(err, "clGetDeviceInfo");
|
|
cl_command_queue_properties valid_properties[] = {
|
|
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_PROFILING_ENABLE
|
|
};
|
|
cl_queue_properties property{ 0 };
|
|
bool missing_property = false;
|
|
// Iterate through all possible properties to find one which isn't supported
|
|
for (auto prop : valid_properties)
|
|
{
|
|
if ((device_queue_properties & prop) == 0)
|
|
{
|
|
missing_property = true;
|
|
property = prop;
|
|
break;
|
|
}
|
|
}
|
|
// This test can only run when a device does not support a property
|
|
if (missing_property)
|
|
{
|
|
clCreateCommandQueue(context, device, property, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_QUEUE_PROPERTIES,
|
|
"clCreateCommandQueue should return CL_INVALID_QUEUE_PROPERTIES "
|
|
"when: \"values specified in properties are valid but are not "
|
|
"supported by the device\"",
|
|
TEST_FAIL);
|
|
}
|
|
|
|
return TEST_PASS;
|
|
}
|
|
|
|
REGISTER_TEST_VERSION(negative_create_command_queue_with_properties,
|
|
Version(2, 0))
|
|
{
|
|
cl_int err = 0;
|
|
clCreateCommandQueueWithProperties(nullptr, device, nullptr, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_CONTEXT,
|
|
"clCreateCommandQueueWithProperties should return CL_INVALID_CONTEXT "
|
|
"when: \"context is not a valid context\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
clCreateCommandQueueWithProperties(context, nullptr, nullptr, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_DEVICE,
|
|
"clCreateCommandQueueWithProperties should return CL_INVALID_DEVICE "
|
|
"when: \"device is not a valid device\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
cl_device_id different_device = GetOpposingDevice(device);
|
|
if (different_device && device != different_device)
|
|
{
|
|
clCreateCommandQueueWithProperties(context, different_device, nullptr,
|
|
&err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_DEVICE,
|
|
"clCreateCommandQueueWithProperties should return "
|
|
"CL_INVALID_DEVICE when: \"device is not associated with context\"",
|
|
TEST_FAIL);
|
|
}
|
|
|
|
cl_queue_properties invalid_property{ static_cast<cl_queue_properties>(
|
|
-1) };
|
|
|
|
// Depending on the OpenCL Version, there can be up to 2 properties which
|
|
// each take values, and the list should be terminated with a 0
|
|
cl_queue_properties properties[] = { invalid_property, invalid_property, 0,
|
|
0, 0 };
|
|
clCreateCommandQueueWithProperties(context, device, properties, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_VALUE,
|
|
"clCreateCommandQueueWithProperties should return CL_INVALID_VALUE "
|
|
"when: \"values specified in properties are not valid\"",
|
|
TEST_FAIL);
|
|
|
|
cl_command_queue_properties device_queue_properties = 0;
|
|
err = clGetDeviceInfo(device, CL_DEVICE_QUEUE_PROPERTIES,
|
|
sizeof(device_queue_properties),
|
|
&device_queue_properties, nullptr);
|
|
test_error(err, "clGetDeviceInfo");
|
|
cl_command_queue_properties valid_properties[] = {
|
|
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_PROFILING_ENABLE
|
|
};
|
|
properties[0] = CL_QUEUE_PROPERTIES;
|
|
bool missing_property = false;
|
|
// Iterate through all possible properties to find one which isn't supported
|
|
for (auto property : valid_properties)
|
|
{
|
|
if ((device_queue_properties & property) == 0)
|
|
{
|
|
missing_property = true;
|
|
properties[1] = property;
|
|
break;
|
|
}
|
|
}
|
|
if (missing_property)
|
|
{
|
|
clCreateCommandQueueWithProperties(context, device, properties, &err);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_QUEUE_PROPERTIES,
|
|
"clCreateCommandQueueWithProperties should return "
|
|
"CL_INVALID_QUEUE_PROPERTIES when: \"values specified in "
|
|
"properties are valid but are not supported by the device\"",
|
|
TEST_FAIL);
|
|
}
|
|
else if (get_device_cl_version(device) >= Version(2, 0))
|
|
{
|
|
cl_uint max_size = -1;
|
|
err = clGetDeviceInfo(device, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE,
|
|
sizeof(max_size), &max_size, nullptr);
|
|
test_error(err, "clGetDeviceInfo");
|
|
if (max_size > 0 && max_size < CL_UINT_MAX)
|
|
{
|
|
properties[0] = CL_QUEUE_PROPERTIES;
|
|
properties[1] =
|
|
CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
|
|
properties[2] = CL_QUEUE_SIZE;
|
|
properties[3] = max_size + 1;
|
|
clCreateCommandQueueWithProperties(context, device, properties,
|
|
&err);
|
|
if (err != CL_INVALID_VALUE && err != CL_INVALID_QUEUE_PROPERTIES)
|
|
{
|
|
log_error("ERROR: %s! (Got %s, expected (%s) from %s:%d)\n",
|
|
"clCreateCommandQueueWithProperties should return "
|
|
"CL_INVALID_VALUE or CL_INVALID_QUEUE_PROPERTIES "
|
|
"when: \"values specified in properties are not "
|
|
"valid\" using a queue size greather than "
|
|
"CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE",
|
|
IGetErrorString(err),
|
|
"CL_INVALID_VALUE or CL_INVALID_QUEUE_PROPERTIES",
|
|
__FILE__, __LINE__);
|
|
return TEST_FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TEST_PASS;
|
|
}
|
|
|
|
REGISTER_TEST(negative_create_command_queue_with_properties_khr)
|
|
{
|
|
if (!is_extension_available(device, "cl_khr_create_command_queue"))
|
|
{
|
|
return TEST_SKIPPED_ITSELF;
|
|
}
|
|
|
|
cl_platform_id platform;
|
|
cl_int error = clGetDeviceInfo(device, CL_DEVICE_PLATFORM,
|
|
sizeof(cl_platform_id), &platform, NULL);
|
|
test_error(error, "clGetDeviceInfo for CL_DEVICE_PLATFORM failed");
|
|
|
|
clCreateCommandQueueWithPropertiesKHR_fn
|
|
clCreateCommandQueueWithPropertiesKHR =
|
|
(clCreateCommandQueueWithPropertiesKHR_fn)
|
|
clGetExtensionFunctionAddressForPlatform(
|
|
platform, "clCreateCommandQueueWithPropertiesKHR");
|
|
if (clCreateCommandQueueWithPropertiesKHR == NULL)
|
|
{
|
|
log_error("ERROR: clGetExtensionFunctionAddressForPlatform failed\n");
|
|
return -1;
|
|
}
|
|
|
|
cl_command_queue_properties device_props = 0;
|
|
error = clGetDeviceInfo(device, CL_DEVICE_QUEUE_PROPERTIES,
|
|
sizeof(device_props), &device_props, NULL);
|
|
test_error(error, "clGetDeviceInfo for CL_DEVICE_QUEUE_PROPERTIES failed");
|
|
|
|
// CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE is the only optional host-queue
|
|
// property to clCreateCommandQueueWithPropertiesKHR,
|
|
// CL_QUEUE_PROFILING_ENABLE is mandatory.
|
|
const bool out_of_order_device_support =
|
|
device_props & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
|
|
if (out_of_order_device_support)
|
|
{
|
|
// Early return as we can't check correct error is returned for
|
|
// unsupported property.
|
|
return TEST_PASS;
|
|
}
|
|
|
|
// Try create a command queue with out-of-order property and check return
|
|
// code
|
|
cl_queue_properties_khr queue_prop_def[] = {
|
|
CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0
|
|
};
|
|
|
|
cl_int test_error = CL_SUCCESS;
|
|
clCommandQueueWrapper test_khr_queue =
|
|
clCreateCommandQueueWithPropertiesKHR(context, device, queue_prop_def,
|
|
&test_error);
|
|
|
|
test_failure_error_ret(test_error, CL_INVALID_QUEUE_PROPERTIES,
|
|
"clCreateCommandQueueWithPropertiesKHR should "
|
|
"return CL_INVALID_QUEUE_PROPERTIES if "
|
|
"values specified in properties are valid but "
|
|
"are not supported by the "
|
|
"device.",
|
|
TEST_FAIL);
|
|
return TEST_PASS;
|
|
}
|
|
|
|
REGISTER_TEST_VERSION(negative_set_default_device_command_queue, Version(2, 1))
|
|
{
|
|
cl_int err = 0;
|
|
if (get_device_cl_version(device) >= Version(3, 0))
|
|
{
|
|
cl_device_device_enqueue_capabilities device_capabilities = 0;
|
|
cl_int err = clGetDeviceInfo(
|
|
device, CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES,
|
|
sizeof(device_capabilities), &device_capabilities, nullptr);
|
|
test_error(err, "clGetDeviceInfo");
|
|
if (((device_capabilities & CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT) == 0)
|
|
&& ((device_capabilities & CL_DEVICE_QUEUE_SUPPORTED) == 1))
|
|
{
|
|
const cl_queue_properties properties[] = {
|
|
CL_QUEUE_PROPERTIES,
|
|
CL_QUEUE_ON_DEVICE_DEFAULT | CL_QUEUE_ON_DEVICE
|
|
| CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
|
|
0
|
|
};
|
|
clCommandQueueWrapper cmd_queue =
|
|
clCreateCommandQueueWithProperties(context, device, properties,
|
|
&err);
|
|
test_error(err, "clCreateCommandQueueWithProperties");
|
|
err = clSetDefaultDeviceCommandQueue(context, device, cmd_queue);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_OPERATION,
|
|
"clSetDefaultDeviceCommandQueue should return "
|
|
"CL_INVALID_OPERATION when \"device does not support a "
|
|
"replaceable default on-device queue\"",
|
|
TEST_FAIL);
|
|
}
|
|
}
|
|
|
|
err = clSetDefaultDeviceCommandQueue(nullptr, device, queue);
|
|
if (err != CL_INVALID_OPERATION && err != CL_INVALID_CONTEXT)
|
|
{
|
|
log_error("ERROR: %s! (Got %s, expected (%s) from %s:%d)\n",
|
|
"clSetDefaultDeviceCommandQueue should return "
|
|
"CL_INVALID_OPERATION or CL_INVALID_CONTEXT when: \"context "
|
|
"is not a valid context\" using a nullptr",
|
|
IGetErrorString(err),
|
|
"CL_INVALID_OPERATION or CL_INVALID_CONTEXT", __FILE__,
|
|
__LINE__);
|
|
return TEST_FAIL;
|
|
}
|
|
|
|
err = clSetDefaultDeviceCommandQueue(context, nullptr, queue);
|
|
if (err != CL_INVALID_OPERATION && err != CL_INVALID_DEVICE)
|
|
{
|
|
log_error("ERROR: %s! (Got %s, expected (%s) from %s:%d)\n",
|
|
"clSetDefaultDeviceCommandQueue should return "
|
|
"CL_INVALID_OPERATION or CL_INVALID_DEVICE when: \"device "
|
|
"is not a valid device\" using a nullptr",
|
|
IGetErrorString(err),
|
|
"CL_INVALID_OPERATION or CL_INVALID_DEVICE", __FILE__,
|
|
__LINE__);
|
|
return TEST_FAIL;
|
|
}
|
|
|
|
cl_device_id different_device = GetOpposingDevice(device);
|
|
if (different_device && device != different_device)
|
|
{
|
|
err = clSetDefaultDeviceCommandQueue(context, different_device, queue);
|
|
if (err != CL_INVALID_OPERATION && err != CL_INVALID_DEVICE)
|
|
{
|
|
log_error("ERROR: %s! (Got %s, expected (%s) from %s:%d)\n",
|
|
"clSetDefaultDeviceCommandQueue should return "
|
|
"CL_INVALID_OPERATION or CL_INVALID_DEVICE when: "
|
|
"\"device is not associated with context\"",
|
|
IGetErrorString(err),
|
|
"CL_INVALID_OPERATION or CL_INVALID_DEVICE", __FILE__,
|
|
__LINE__);
|
|
return TEST_FAIL;
|
|
}
|
|
}
|
|
err = clSetDefaultDeviceCommandQueue(context, device, nullptr);
|
|
if (err != CL_INVALID_OPERATION && err != CL_INVALID_COMMAND_QUEUE)
|
|
{
|
|
log_error(
|
|
"ERROR: %s! (Got %s, expected (%s) from %s:%d)\n",
|
|
"clSetDefaultDeviceCommandQueue should return CL_INVALID_OPERATION "
|
|
"or CL_INVALID_COMMAND_QUEUE when: \"command_queue is not a valid "
|
|
"command-queue for device\" using a nullptr",
|
|
IGetErrorString(err),
|
|
"CL_INVALID_OPERATION or CL_INVALID_COMMAND_QUEUE", __FILE__,
|
|
__LINE__);
|
|
return TEST_FAIL;
|
|
}
|
|
|
|
{
|
|
cl_command_queue_properties queue_properties;
|
|
err =
|
|
clGetDeviceInfo(device, CL_DEVICE_QUEUE_PROPERTIES,
|
|
sizeof(queue_properties), &queue_properties, NULL);
|
|
test_error(err, "Unable to query CL_DEVICE_QUEUE_PROPERTIES");
|
|
if (queue_properties & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
|
|
{
|
|
constexpr cl_queue_properties props[] = {
|
|
CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0
|
|
};
|
|
clCommandQueueWrapper not_on_device_queue =
|
|
clCreateCommandQueueWithProperties(context, device, props,
|
|
&err);
|
|
test_error_fail(err, "clCreateCommandQueueWithProperties failed");
|
|
err = clSetDefaultDeviceCommandQueue(context, device,
|
|
not_on_device_queue);
|
|
if (err != CL_INVALID_OPERATION && err != CL_INVALID_COMMAND_QUEUE)
|
|
{
|
|
log_error(
|
|
"ERROR: %s! (Got %s, expected (%s) from %s:%d)\n",
|
|
"clSetDefaultDeviceCommandQueue should return "
|
|
"CL_INVALID_OPERATION or CL_INVALID_COMMAND_QUEUE when: "
|
|
"\"command_queue is not a valid command-queue for "
|
|
"device\" using a command queue that is not on device",
|
|
IGetErrorString(err),
|
|
"CL_INVALID_OPERATION or CL_INVALID_COMMAND_QUEUE",
|
|
__FILE__, __LINE__);
|
|
}
|
|
}
|
|
}
|
|
|
|
return TEST_PASS;
|
|
}
|
|
|
|
REGISTER_TEST(negative_retain_command_queue)
|
|
{
|
|
cl_int err = clRetainCommandQueue(nullptr);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_COMMAND_QUEUE,
|
|
"clRetainCommandQueue should return CL_INVALID_COMMAND_QUEUE when: "
|
|
"\"command_queue is not a valid command-queue\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
return TEST_PASS;
|
|
}
|
|
|
|
REGISTER_TEST(negative_release_command_queue)
|
|
{
|
|
cl_int err = clReleaseCommandQueue(nullptr);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_COMMAND_QUEUE,
|
|
"clReleaseCommandQueue should return CL_INVALID_COMMAND_QUEUE when: "
|
|
"\"command_queue is not a valid command-queue\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
return TEST_PASS;
|
|
}
|
|
|
|
static bool device_supports_on_device_queue(cl_device_id deviceID)
|
|
{
|
|
cl_command_queue_properties device_queue_properties = 0;
|
|
if (get_device_cl_version(deviceID) >= Version(2, 0))
|
|
{
|
|
cl_int err = clGetDeviceInfo(
|
|
deviceID, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES,
|
|
sizeof(device_queue_properties), &device_queue_properties, nullptr);
|
|
test_error(err, "clGetDeviceInfo");
|
|
return (device_queue_properties
|
|
& CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
REGISTER_TEST(negative_get_command_queue_info)
|
|
{
|
|
cl_int err =
|
|
clGetCommandQueueInfo(nullptr, CL_QUEUE_CONTEXT, 0, nullptr, nullptr);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_COMMAND_QUEUE,
|
|
"clGetCommandQueueInfo should return CL_INVALID_COMMAND_QUEUE when: "
|
|
"\"command_queue is not a valid command-queue\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
if (device_supports_on_device_queue(device))
|
|
{
|
|
const cl_queue_properties properties[] = {
|
|
CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0
|
|
};
|
|
cl_int err = CL_INVALID_VALUE;
|
|
clCommandQueueWrapper cmd_queue = clCreateCommandQueueWithProperties(
|
|
context, device, properties, &err);
|
|
test_error(err, "clCreateCommandQueueWithProperties");
|
|
cl_uint queue_size = -1;
|
|
err = clGetCommandQueueInfo(cmd_queue, CL_QUEUE_SIZE,
|
|
sizeof(queue_size), &queue_size, nullptr);
|
|
test_failure_error_ret(err, CL_INVALID_COMMAND_QUEUE,
|
|
"clGetCommandQueueInfo should return "
|
|
"CL_INVALID_COMMAND_QUEUE when: \"command_queue "
|
|
"is not a valid command-queue for param_name\"",
|
|
TEST_FAIL);
|
|
}
|
|
|
|
constexpr cl_command_queue_info invalid_param = -1;
|
|
err = clGetCommandQueueInfo(queue, invalid_param, 0, nullptr, nullptr);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_VALUE,
|
|
"clGetCommandQueueInfo should return CL_INVALID_VALUE when: "
|
|
"\"param_name is not one of the supported values\"",
|
|
TEST_FAIL);
|
|
|
|
|
|
cl_uint ref_count = -1;
|
|
err = clGetCommandQueueInfo(queue, CL_QUEUE_REFERENCE_COUNT, 0, &ref_count,
|
|
nullptr);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_VALUE,
|
|
"clGetCommandQueueInfo should return CL_INVALID_VALUE when: \"size in "
|
|
"bytes specified by param_value_size is < size of return type and "
|
|
"param_value is not a NULL value\"",
|
|
TEST_FAIL);
|
|
|
|
return TEST_PASS;
|
|
}
|
|
|
|
REGISTER_TEST_VERSION(negative_set_command_queue_property, Version(1, 0))
|
|
{
|
|
auto version = get_device_cl_version(device);
|
|
if (version >= Version(1, 1))
|
|
{
|
|
// Implementations are allowed to return an error for
|
|
// non-OpenCL 1.0 devices. In which case, skip the test.
|
|
return TEST_SKIPPED_ITSELF;
|
|
}
|
|
|
|
cl_queue_properties property{ CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE };
|
|
cl_int err = clSetCommandQueueProperty(nullptr, property, CL_TRUE, nullptr);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_COMMAND_QUEUE,
|
|
"clSetCommandQueueProperty should return CL_INVALID_COMMAND_QUEUE "
|
|
"when: \"command_queue is not a valid command-queue\" using a nullptr",
|
|
TEST_FAIL);
|
|
|
|
property = -1;
|
|
err = clSetCommandQueueProperty(queue, property, CL_TRUE, nullptr);
|
|
test_failure_error_ret(
|
|
err, CL_INVALID_VALUE,
|
|
"clSetCommandQueueProperty should return CL_INVALID_VALUE when: "
|
|
"\"values specified in properties are not valid\"",
|
|
TEST_FAIL);
|
|
|
|
return TEST_PASS;
|
|
}
|