}
}
- if (limits->viewportBoundsRange[0] > -2 * limits->maxViewportDimensions[0])
+ if (limits->viewportBoundsRange[0] > float(-2 * limits->maxViewportDimensions[0]))
{
log << TestLog::Message << "limit validation failed, viewPortBoundsRange[0] of " << limits->viewportBoundsRange[0]
<< "is larger than -2*maxViewportDimension[0] of " << -2*limits->maxViewportDimensions[0] << TestLog::EndMessage;
limitsOk = false;
}
- if (limits->viewportBoundsRange[1] < 2 * limits->maxViewportDimensions[1] - 1)
+ if (limits->viewportBoundsRange[1] < float(2 * limits->maxViewportDimensions[1] - 1))
{
log << TestLog::Message << "limit validation failed, viewportBoundsRange[1] of " << limits->viewportBoundsRange[1]
<< "is less than 2*maxViewportDimension[1] of " << 2*limits->maxViewportDimensions[1] << TestLog::EndMessage;
"VK_KHR_sampler_mirror_clamp_to_edge",
"VK_KHR_shader_draw_parameters",
"VK_KHR_maintenance1",
+ "VK_KHR_push_descriptor",
+ "VK_KHR_descriptor_update_template",
};
checkKhrExtensions(results, extensions, DE_LENGTH_OF_ARRAY(s_allowedDeviceKhrExtensions), s_allowedDeviceKhrExtensions);
if (isCompressedFormat(format) && (imageType == VK_IMAGE_TYPE_1D || imageType == VK_IMAGE_TYPE_3D))
return false;
+ // Support for 1D and 3D depth/stencil textures is optional
+ if (isDepthStencilFormat(format) && (imageType == VK_IMAGE_TYPE_1D || imageType == VK_IMAGE_TYPE_3D))
+ return false;
+
DE_ASSERT(deviceFeatures.sparseBinding || (createFlags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)) == 0);
DE_ASSERT(deviceFeatures.sparseResidencyAliased || (createFlags & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) == 0);
results.check(imageType != VK_IMAGE_TYPE_3D || (properties.maxExtent.width >= 1 && properties.maxExtent.height >= 1 && properties.maxExtent.depth >= 1), "Invalid dimensions for 3D image");
results.check(imageType != VK_IMAGE_TYPE_3D || properties.maxArrayLayers == 1, "Invalid maxArrayLayers for 3D image");
- if (tiling == VK_IMAGE_TILING_OPTIMAL && imageType == VK_IMAGE_TYPE_2D && !(curCreateFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
- ((supportedFeatures & (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) ||
- ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) && deviceFeatures.shaderStorageImageMultisample)))
+ if (tiling == VK_IMAGE_TILING_OPTIMAL)
{
- const VkSampleCountFlags requiredSampleCounts = getRequiredOptimalTilingSampleCounts(deviceLimits, format, curUsageFlags);
- results.check((properties.sampleCounts & requiredSampleCounts) == requiredSampleCounts, "Required sample counts not supported");
+ // Vulkan API specification has changed since initial Android Nougat release.
+ // For NYC CTS we need to tolerate old behavior as well and issue compatibility
+ // warning instead.
+ //
+ // See spec issues 272, 282, 302, 445 and CTS issues 369, 440.
+ const bool requiredByNewSpec = (imageType == VK_IMAGE_TYPE_2D && !(curCreateFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
+ ((supportedFeatures & (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) ||
+ ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) && deviceFeatures.shaderStorageImageMultisample)));
+
+ if (requiredByNewSpec)
+ {
+ const VkSampleCountFlags requiredSampleCounts = getRequiredOptimalTilingSampleCounts(deviceLimits, format, curUsageFlags);
+
+ results.check((properties.sampleCounts & requiredSampleCounts) == requiredSampleCounts, "Required sample counts not supported");
+ }
+ else if (properties.sampleCounts != VK_SAMPLE_COUNT_1_BIT)
+ {
+ results.addResult(QP_TEST_RESULT_COMPATIBILITY_WARNING,
+ "Implementation supports more sample counts than allowed by the spec");
+ }
}
else
results.check(properties.sampleCounts == VK_SAMPLE_COUNT_1_BIT, "sampleCounts != VK_SAMPLE_COUNT_1_BIT");
{
const VkPhysicalDevice physicalDevice = devices[deviceNdx];
- for (VkImageUsageFlags curUsageFlags = 0; curUsageFlags <= allUsageFlags; curUsageFlags++)
+ for (VkImageUsageFlags curUsageFlags = (VkImageUsageFlags)1; curUsageFlags <= allUsageFlags; curUsageFlags++)
{
for (VkImageCreateFlags curCreateFlags = 0; curCreateFlags <= allCreateFlags; curCreateFlags++)
{
{
const VkPhysicalDevice physicalDevice = devices[deviceNdx];
- for (deUint32 sampleCount = 1; sampleCount <= 64; sampleCount++)
+ for (deUint32 sampleCountBit = VK_SAMPLE_COUNT_1_BIT; sampleCountBit <= VK_SAMPLE_COUNT_64_BIT; sampleCountBit = (sampleCountBit << 1u))
{
- const VkSampleCountFlagBits sampleCountFlagBit = (VkSampleCountFlagBits)(1u<<sampleCount);
-
- for (VkImageUsageFlags curUsageFlags = 0; curUsageFlags <= allUsageFlags; curUsageFlags++)
+ for (VkImageUsageFlags curUsageFlags = (VkImageUsageFlags)1; curUsageFlags <= allUsageFlags; curUsageFlags++)
{
const VkPhysicalDeviceSparseImageFormatInfo2KHR imageFormatInfo =
{
DE_NULL,
format,
imageType,
- sampleCountFlagBit,
+ (VkSampleCountFlagBits)sampleCountBit,
curUsageFlags,
tiling,
};
return tcu::TestStatus::pass("Querying sparse image format properties succeeded");
}
+// Android CTS -specific tests
+
+namespace android
+{
+
+void checkExtensions (tcu::ResultCollector& results, const set<string>& allowedExtensions, const vector<VkExtensionProperties>& reportedExtensions)
+{
+ for (vector<VkExtensionProperties>::const_iterator extension = reportedExtensions.begin(); extension != reportedExtensions.end(); ++extension)
+ {
+ const string extensionName (extension->extensionName);
+ const bool mustBeKnown = de::beginsWith(extensionName, "VK_KHX_") ||
+ de::beginsWith(extensionName, "VK_GOOGLE_") ||
+ de::beginsWith(extensionName, "VK_ANDROID_");
+
+ if (mustBeKnown && !de::contains(allowedExtensions, extensionName))
+ results.fail("Unknown extension: " + extensionName);
+ }
+}
+
+tcu::TestStatus testNoUnknownExtensions (Context& context)
+{
+ TestLog& log = context.getTestContext().getLog();
+ tcu::ResultCollector results (log);
+ set<string> allowedInstanceExtensions;
+ set<string> allowedDeviceExtensions;
+
+ // All known extensions should be added to allowedExtensions:
+ // allowedExtensions.insert("VK_GOOGLE_extension1");
+ allowedDeviceExtensions.insert("VK_GOOGLE_display_timing");
+
+ // Instance extensions
+ checkExtensions(results,
+ allowedInstanceExtensions,
+ enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL));
+
+ // Extensions exposed by instance layers
+ {
+ const vector<VkLayerProperties> layers = enumerateInstanceLayerProperties(context.getPlatformInterface());
+
+ for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
+ {
+ checkExtensions(results,
+ allowedInstanceExtensions,
+ enumerateInstanceExtensionProperties(context.getPlatformInterface(), layer->layerName));
+ }
+ }
+
+ // Device extensions
+ checkExtensions(results,
+ allowedDeviceExtensions,
+ enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL));
+
+ // Extensions exposed by device layers
+ {
+ const vector<VkLayerProperties> layers = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
+
+ for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
+ {
+ checkExtensions(results,
+ allowedDeviceExtensions,
+ enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), layer->layerName));
+ }
+ }
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+tcu::TestStatus testNoLayers (Context& context)
+{
+ TestLog& log = context.getTestContext().getLog();
+ tcu::ResultCollector results (log);
+
+ {
+ const vector<VkLayerProperties> layers = enumerateInstanceLayerProperties(context.getPlatformInterface());
+
+ for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
+ results.fail(string("Instance layer enumerated: ") + layer->layerName);
+ }
+
+ {
+ const vector<VkLayerProperties> layers = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
+
+ for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
+ results.fail(string("Device layer enumerated: ") + layer->layerName);
+ }
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+tcu::TestStatus testMandatoryExtensions (Context& context)
+{
+ TestLog& log = context.getTestContext().getLog();
+ tcu::ResultCollector results (log);
+
+ // Instance extensions
+ {
+ static const char* mandatoryExtensions[] =
+ {
+ "VK_KHR_get_physical_device_properties2",
+ };
+ const vector<VkExtensionProperties> extensions = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
+
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(mandatoryExtensions); ++ndx)
+ {
+ if (!isExtensionSupported(extensions, RequiredExtension(mandatoryExtensions[ndx])))
+ results.fail(string(mandatoryExtensions[ndx]) + " is not supported");
+ }
+ }
+
+ // Device extensions
+ {
+ static const char* mandatoryExtensions[] =
+ {
+ "VK_KHR_maintenance1",
+ };
+ const vector<VkExtensionProperties> extensions = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
+
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(mandatoryExtensions); ++ndx)
+ {
+ if (!isExtensionSupported(extensions, RequiredExtension(mandatoryExtensions[ndx])))
+ results.fail(string(mandatoryExtensions[ndx]) + " is not supported");
+ }
+ }
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+} // android
+
} // anonymous
tcu::TestCaseGroup* createFeatureInfoTests (tcu::TestContext& testCtx)
infoTests->addChild(createTestGroup(testCtx, "image_format_properties2", "VkGetPhysicalDeviceImageFormatProperties2KHR() Tests", createImageFormatTests, imageFormatProperties2));
infoTests->addChild(createTestGroup(testCtx, "sparse_image_format_properties2", "VkGetPhysicalDeviceSparseImageFormatProperties2KHR() Tests", createImageFormatTests, sparseImageFormatProperties2));
+ {
+ de::MovePtr<tcu::TestCaseGroup> androidTests (new tcu::TestCaseGroup(testCtx, "android", "Android CTS Tests"));
+
+ addFunctionCase(androidTests.get(), "mandatory_extensions", "Test that all mandatory extensions are supported", android::testMandatoryExtensions);
+ addFunctionCase(androidTests.get(), "no_unknown_extensions", "Test for unknown device or instance extensions", android::testNoUnknownExtensions);
+ addFunctionCase(androidTests.get(), "no_layers", "Test that no layers are enumerated", android::testNoLayers);
+
+ infoTests->addChild(androidTests.release());
+ }
+
return infoTests.release();
}
projects / platform / upstream / VK-GL-CTS.git / blobdiff