std::list<check_mem_filter::filter_obj> get_memory() {
std::list<check_mem_filter::filter_obj> ret;
check_mem_filter::filter_obj physical("physical", 0, 0);
check_mem_filter::filter_obj swap("swap", 0, 0);
long long cached = 0;
try {
std::locale mylocale("C");
std::ifstream file;
file.imbue(mylocale);
file.open(MEMINFO_FILE);
std::string line;
while (std::getline(file, line)) {
std::stringstream iss(line);
std::string tag;
iss >> tag;
if (tag == "MemTotal:")
physical.total = read_mem_line(iss);
else if (tag == "MemFree:")
physical.free = read_mem_line(iss);
else if (tag == "Buffers:" || tag == "Cached:")
cached += read_mem_line(iss);
else if (tag == "SwapTotal:")
swap.total += read_mem_line(iss);
else if (tag == "SwapFree:")
swap.free += read_mem_line(iss);
}
ret.push_back(physical);
ret.push_back(check_mem_filter::filter_obj("cached", physical.get_used()-cached, physical.total));
ret.push_back(swap);
} catch (const std::exception &e) {
return ret;
}
return ret;
}
int QLCFixtureMode_Test::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: initTestCase(); break;
case 1: fixtureDef(); break;
case 2: name(); break;
case 3: physical(); break;
case 4: insertChannel(); break;
case 5: removeChannel(); break;
case 6: channelByName(); break;
case 7: channelByIndex(); break;
case 8: channels(); break;
case 9: channelNumber(); break;
case 10: copy(); break;
case 11: load(); break;
case 12: loadWrongRoot(); break;
case 13: loadNoName(); break;
case 14: save(); break;
case 15: cleanupTestCase(); break;
default: ;
}
_id -= 16;
}
return _id;
}
TEST(WrapObjects, Insert)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t familyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
std::unique_ptr<VkQueueFamilyProperties[]> family(new VkQueueFamilyProperties[familyCount]);
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, family.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
for(uint32_t q = 0; q < familyCount; ++q)
{
if(~family[q].queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
continue;
}
float const priorities[] = {0.0f}; // Temporary required due to MSVC bug.
VkDeviceQueueCreateInfo const queueInfo[1]
{
VK::DeviceQueueCreateInfo().
queueFamilyIndex(q).
queueCount(1).
pQueuePriorities(priorities)
};
auto const deviceInfo = VK::DeviceCreateInfo().
queueCreateInfoCount(1).
pQueueCreateInfos(queueInfo);
VkDevice device;
result = vkCreateDevice(physical[p], deviceInfo, nullptr, &device);
ASSERT_EQ(result, VK_SUCCESS);
vkDestroyDevice(device, nullptr);
}
}
vkDestroyInstance(instance, nullptr);
}
void setlast(int disk, int *track, int *head, int sysonly)
{
int i;
struct DEVICEPARAMS dp;
long fatsector,lastsec;
int secsfat,datasec;
unsigned int nclusters;
unsigned short maxcluster;
if ((i = disk_getparams(disk,&dp)) != DISK_OK)
{
/* LIB TODO: make a strliberror() function (like strerror()) */
lib_error("getlast()",i);
exit(1);
}
if (sysonly)
{
datasec = data_sector(&dp);
physical(track,NULL,head,datasec,dp.hidden_sectors,dp.secs_track,
dp.num_heads);
printf("System extends to track %d, side %d (logical sector %d).\n",
MaxTrack,MaxHead,datasec);
return;
}
nclusters = num_clusters(&dp);
fatsector = dp.reserved_secs;
secsfat = dp.secs_fat;
maxcluster = searchfat12(disk,(unsigned short)nclusters,
fatsector,secsfat,0);
if (maxcluster == 0)
die("There seems to be no data on the disk in ","%c:.",disk+'A');
datasec = data_sector(&dp);
lastsec = cluster_to_sector(maxcluster,datasec,dp.secs_cluster);
lastsec += (dp.secs_cluster-1);
physical(track,NULL,head,lastsec,dp.hidden_sectors,dp.secs_track,
dp.num_heads);
printf("Last allocated cluster, %u, is on ",maxcluster);
printf("track %d, side %d.\n",MaxTrack,MaxHead);
}
QRectF Fixture::degreesRange(int head) const
{
// TODO: handle fixtures with only pan or tilt
if (m_fixtureMode != NULL && head < m_fixtureMode->heads().size())
{
QLCPhysical physical(m_fixtureMode->physical());
qreal pan = physical.focusPanMax();
qreal tilt = physical.focusTiltMax();
if (pan != 0 && tilt != 0)
{
return QRectF(-pan/2, -tilt/2, pan, tilt);
}
}
return QRectF();
}
TEST(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t count = 0u;
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]);
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, properties.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_NE(std::find_if(
&properties[0],
&properties[count],
[](VkExtensionProperties const& properties)
{
return strcmp(properties.extensionName, "VK_KHR_swapchain") == 0;
}),
&properties[count]);
}
vkDestroyInstance(instance, nullptr);
}
void SimulatorParameters::loadPhysicalParameters(int dim){
ifstream fid;
string str;
// read physical parameters
string physical(parametersPath + "/physical.dat");
fid.open(physical.c_str());
if ( !fid.is_open() ) throw Exception(__LINE__,__FILE__,"physical.dat could not be opened or it doesn't exist.\n");
// start reading file
setPositionToRead(fid,"Oil density");
fid >> str; _oil_density = strtod(str.c_str(), 0);
setPositionToRead(fid,"Water density:");
fid >> str; _water_density = strtod(str.c_str(), 0);
setPositionToRead(fid,"Oil viscosity:");
fid >> str; _oil_viscosity = strtod(str.c_str(), 0);
setPositionToRead(fid,"Water viscosity:");
fid >> str; _water_viscosity = strtod(str.c_str(), 0);
setPositionToRead(fid,"# dom, K and phi:");
readRockProperties(fid,dim);
setPositionToRead(fid,"Residual Oil Satutarion");
fid >> str; _Sor = strtod(str.c_str(), 0);
setPositionToRead(fid,"Irreducible Water Satutarion");
fid >> str; _Swr = strtod(str.c_str(), 0);
setPositionToRead(fid,"type model ID right above:");
fid >> _ksModel;
// printf("_ksModel = %d\n",_ksModel); throw 1;
fid.close();
getDomains();
}
TEST(EnumerateDeviceExtensionProperties, PropertyCountLessThanAvailable)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t count = 0u;
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
// We need atleast two for the test to be relevant.
if(count < 2u)
{
continue;
}
std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]);
count = 1;
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, properties.get());
ASSERT_EQ(result, VK_INCOMPLETE);
}
vkDestroyInstance(instance, nullptr);
}
public: virtual const Physical& thread_reg() const override {
return physical($tcb);
}
TEST(CreateDevice, ExtensionNotPresent)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t familyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
std::unique_ptr<VkQueueFamilyProperties[]> family(new VkQueueFamilyProperties[familyCount]);
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, family.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
for(uint32_t q = 0; q < familyCount; ++q)
{
if(~family[q].queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
continue;
}
float const priorities[] = {0.0f}; // Temporary required due to MSVC bug.
VkDeviceQueueCreateInfo const queueInfo[1]
{
VK::DeviceQueueCreateInfo().
queueFamilyIndex(q).
queueCount(1).
pQueuePriorities(priorities)
};
char const*const names[] = {"NotPresent"}; // Temporary required due to MSVC bug.
auto const deviceInfo = VK::DeviceCreateInfo().
queueCreateInfoCount(1).
pQueueCreateInfos(queueInfo).
enabledExtensionCount(1).
ppEnabledExtensionNames(names);
VkDevice device;
result = vkCreateDevice(physical[p], deviceInfo, nullptr, &device);
ASSERT_EQ(result, VK_ERROR_EXTENSION_NOT_PRESENT);
// It's not necessary to destroy the device because it will not be created successfully.
}
}
vkDestroyInstance(instance, nullptr);
}
void Mssm<Two_scale>::calculate_spectrum()
{
run_to(maximum(displayMsusy(), MZ));
physical(3);
runto(displayMz());
}
