mirror of
https://github.com/OpenFOAM/ThirdParty-6.git
synced 2025-12-08 06:57:43 +00:00
316 lines
8.2 KiB
C++
316 lines
8.2 KiB
C++
#include "vtkClientServerStream.h"
|
|
#include "vtkVariantArray.h"
|
|
#include "vtkStringArray.h"
|
|
#include "vtkDoubleArray.h"
|
|
#include "vtkNew.h"
|
|
|
|
static double dblIni[] = { 904., 906., 917. };
|
|
static const char* strIni[] = { "901", "Turbo", "Targa" };
|
|
|
|
template <class T>
|
|
struct Help
|
|
{
|
|
static void Store(vtkClientServerStream& css)
|
|
{
|
|
T v = 123;
|
|
T a[2] = {12, 3};
|
|
css << v << vtkClientServerStream::InsertArray(a, 2);
|
|
}
|
|
static bool Check(vtkClientServerStream& css, int& arg)
|
|
{
|
|
T v;
|
|
T a[2];
|
|
if(!css.GetArgument(0, arg++, &v) || v != 123)
|
|
{
|
|
return false;
|
|
}
|
|
if(!css.GetArgument(0, arg++, a, 2) || a[0] != 12 || a[1] != 3)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Store a bunch of values in a stream.
|
|
void do_store(vtkClientServerStream& css)
|
|
{
|
|
vtkClientServerID id(123);
|
|
css.Reserve(64);
|
|
css.Reset();
|
|
css << vtkClientServerStream::Reply;
|
|
css << true;
|
|
css << id;
|
|
Help<char>::Store(css);
|
|
Help<short>::Store(css);
|
|
Help<int>::Store(css);
|
|
Help<long>::Store(css);
|
|
Help<signed char>::Store(css);
|
|
Help<unsigned char>::Store(css);
|
|
Help<unsigned short>::Store(css);
|
|
Help<unsigned int>::Store(css);
|
|
Help<unsigned long>::Store(css);
|
|
#if defined(VTK_TYPE_USE_LONG_LONG)
|
|
Help<long long>::Store(css);
|
|
Help<unsigned long long>::Store(css);
|
|
#endif
|
|
#if defined(VTK_TYPE_USE___INT64)
|
|
Help<__int64>::Store(css);
|
|
Help<unsigned __int64>::Store(css);
|
|
#endif
|
|
Help<float>::Store(css);
|
|
Help<double>::Store(css);
|
|
|
|
vtkVariant varStr("911");
|
|
css << varStr;
|
|
vtkVariant varNum(356.0);
|
|
css << varNum;
|
|
|
|
// Test a variant that is itself an array of primitives (doubles).
|
|
vtkNew<vtkDoubleArray> dblArr;
|
|
dblArr->SetArray(dblIni, sizeof(dblIni) / sizeof(dblIni[0]), 1);
|
|
vtkVariant varDblArr(dblArr.GetPointer());
|
|
css << varDblArr;
|
|
|
|
// Test a variant that is itself an array of composites (strings).
|
|
vtkNew<vtkStringArray> strArr;
|
|
strArr->SetNumberOfValues(sizeof(strIni) / sizeof(strIni[0]));
|
|
for (vtkIdType i = 0; i < strArr->GetNumberOfValues(); ++i)
|
|
{
|
|
strArr->SetValue(i, strIni[i]);
|
|
}
|
|
vtkVariant varStrArr(strArr.GetPointer());
|
|
css << varStrArr;
|
|
|
|
// Test a variant that is itself an array of composites (variants).
|
|
vtkNew<vtkVariantArray> varArr;
|
|
varArr->SetNumberOfValues(sizeof(strIni) / sizeof(strIni[0]));
|
|
for (vtkIdType i = 0; i < varArr->GetNumberOfValues(); ++i)
|
|
{
|
|
vtkVariant tmp(strIni[i]);
|
|
bool numeric;
|
|
double x = tmp.ToDouble(&numeric);
|
|
if (numeric)
|
|
{
|
|
varArr->SetVariantValue(i, x);
|
|
}
|
|
else
|
|
{
|
|
varArr->SetVariantValue(i, strIni[i]);
|
|
}
|
|
}
|
|
vtkVariant varVarArr(varArr.GetPointer());
|
|
css << varVarArr;
|
|
|
|
vtkVariant varInvalid;
|
|
css << varInvalid;
|
|
|
|
css << "123";
|
|
{
|
|
vtkClientServerStream nested;
|
|
nested << vtkClientServerStream::Reply
|
|
<< "456"
|
|
<< vtkClientServerStream::End;
|
|
css << nested;
|
|
}
|
|
css << vtkClientServerStream::End;
|
|
}
|
|
|
|
// Check stored values in a stream.
|
|
bool do_check(vtkClientServerStream& css)
|
|
{
|
|
if(css.GetNumberOfMessages() != 1)
|
|
{
|
|
return false;
|
|
}
|
|
if(css.GetCommand(0) != vtkClientServerStream::Reply)
|
|
{
|
|
return false;
|
|
}
|
|
int arg = 0;
|
|
{
|
|
bool b;
|
|
if(!css.GetArgument(0, arg++, &b) || b != true)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
{
|
|
vtkClientServerID id;
|
|
if(!css.GetArgument(0, arg++, &id) || id.ID != 123)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
{
|
|
if(!Help<char>::Check(css, arg)) { return false; }
|
|
if(!Help<short>::Check(css, arg)) { return false; }
|
|
if(!Help<int>::Check(css, arg)) { return false; }
|
|
if(!Help<long>::Check(css, arg)) { return false; }
|
|
if(!Help<signed char>::Check(css, arg)) { return false; }
|
|
if(!Help<unsigned char>::Check(css, arg)) { return false; }
|
|
if(!Help<unsigned short>::Check(css, arg)) { return false; }
|
|
if(!Help<unsigned int>::Check(css, arg)) { return false; }
|
|
if(!Help<unsigned long>::Check(css, arg)) { return false; }
|
|
#if defined(VTK_TYPE_USE_LONG_LONG)
|
|
if(!Help<long long>::Check(css, arg)) { return false; }
|
|
if(!Help<unsigned long long>::Check(css, arg)) { return false; }
|
|
#endif
|
|
#if defined(VTK_TYPE_USE___INT64)
|
|
if(!Help<__int64>::Check(css, arg)) { return false; }
|
|
if(!Help<unsigned __int64>::Check(css, arg)) { return false; }
|
|
#endif
|
|
if(!Help<float>::Check(css, arg)) { return false; }
|
|
if(!Help<double>::Check(css, arg)) { return false; }
|
|
}
|
|
{
|
|
vtkVariant varOut;
|
|
if (!css.GetArgument(0, arg, &varOut) || varOut.ToString() != "911")
|
|
{
|
|
cout << "Variant was \"" << varOut.ToString().c_str() << "\" instead of 911\n";
|
|
return false;
|
|
}
|
|
if (!css.GetArgument(0, arg, &varOut) || varOut.ToDouble() != 356.0 )
|
|
{
|
|
cout << "Variant was \"" << varOut.ToString().c_str() << "\" instead of 356.0\n";
|
|
return false;
|
|
}
|
|
vtkDoubleArray* dblArr;
|
|
if (
|
|
!css.GetArgument(0, arg, &varOut) ||
|
|
!(dblArr = vtkDoubleArray::SafeDownCast(varOut.ToArray())) ||
|
|
dblArr->GetMaxId() != (sizeof(dblIni) / sizeof(dblIni[0]) - 1) ||
|
|
dblArr->GetValue(0) != dblIni[0] ||
|
|
dblArr->GetValue(1) != dblIni[1] ||
|
|
dblArr->GetValue(2) != dblIni[2]
|
|
)
|
|
{
|
|
cout << "Variant was \"" << varOut.ToString().c_str() << "\" instead of (904.0, 906.0, 917.0)\n";
|
|
return false;
|
|
}
|
|
vtkStringArray* strArr;
|
|
if (
|
|
!css.GetArgument(0, arg, &varOut) ||
|
|
!(strArr = vtkStringArray::SafeDownCast(varOut.ToArray())) ||
|
|
strArr->GetMaxId() != (sizeof(strIni) / sizeof(strIni[0]) - 1) ||
|
|
strArr->GetValue(0) != strIni[0] ||
|
|
strArr->GetValue(1) != strIni[1] ||
|
|
strArr->GetValue(2) != strIni[2]
|
|
)
|
|
{
|
|
cout << "Variant was \"" << varOut.ToString().c_str() << "\" instead of (\"901\", \"Turbo\", \"Targa\")\n";
|
|
return false;
|
|
}
|
|
vtkVariantArray* varArr;
|
|
if (
|
|
!css.GetArgument(0, arg, &varOut) ||
|
|
!(varArr = vtkVariantArray::SafeDownCast(varOut.ToArray())) ||
|
|
varArr->GetMaxId() != (sizeof(strIni) / sizeof(strIni[0]) - 1) ||
|
|
varArr->GetValue(0) != vtkVariant(strIni[0]).ToDouble() ||
|
|
varArr->GetValue(1) != strIni[1] ||
|
|
varArr->GetValue(2) != strIni[2]
|
|
)
|
|
{
|
|
cout << "Variant was \"" << varOut.ToString().c_str() << "\" instead of (901.0, \"Turbo\", \"Targa\")\n";
|
|
return false;
|
|
}
|
|
if (!css.GetArgument(0, arg, &varOut) || varOut.IsValid())
|
|
{
|
|
cout << "Variant that was supposed to be invalid is valid\n";
|
|
return false;
|
|
}
|
|
}
|
|
{
|
|
const char* s;
|
|
if(!css.GetArgument(0, arg++, &s) || strcmp(s, "123") != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
{
|
|
const char* s;
|
|
vtkClientServerStream nested;
|
|
if(!css.GetArgument(0, arg++, &nested))
|
|
{
|
|
return false;
|
|
}
|
|
if(!nested.GetArgument(0, 0, &s) || strcmp(s, "456") != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool do_test()
|
|
{
|
|
// Construct a stream and store values.
|
|
vtkClientServerStream css1;
|
|
do_store(css1);
|
|
|
|
// Cover stream print code.
|
|
cout << "-----------------------------------------------------------\n";
|
|
css1.Print(cout);
|
|
cout << "-----------------------------------------------------------\n";
|
|
|
|
// Copy the stream in various ways.
|
|
vtkClientServerStream css2(css1);
|
|
vtkClientServerStream css3;
|
|
css3.Copy(&css2);
|
|
vtkClientServerStream css4;
|
|
if(!css4.StreamFromString(css3.StreamToString()))
|
|
{
|
|
cerr << "FAILED: StreamToString or StreamFromString failed." << endl;
|
|
return false;
|
|
}
|
|
vtkClientServerStream css5;
|
|
{
|
|
const unsigned char* data;
|
|
size_t length;
|
|
if(!css4.GetData(&data, &length))
|
|
{
|
|
cerr << "FAILED: GetData failed." << endl;
|
|
return false;
|
|
}
|
|
if(!css5.SetData(data, length))
|
|
{
|
|
cerr << "FAILED: SetData failed." << endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(!do_check(css1))
|
|
{
|
|
cerr << "FAILED: Stream contents could not correctly be retrieved."
|
|
<< endl;
|
|
return false;
|
|
}
|
|
if(!do_check(css2))
|
|
{
|
|
cerr << "FAILED: Copy constructor did not copy stream properly." << endl;
|
|
return false;
|
|
}
|
|
if(!do_check(css3))
|
|
{
|
|
cerr << "FAILED: Copy method did not copy stream properly." << endl;
|
|
return false;
|
|
}
|
|
if(!do_check(css4))
|
|
{
|
|
cerr << "FAILED: String(To/From)Stream did not copy stream properly."
|
|
<< endl;
|
|
return false;
|
|
}
|
|
if(!do_check(css5))
|
|
{
|
|
cerr << "FAILED: (Get/Set)Data did not copy stream properly." << endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int coverClientServer(int, char*[])
|
|
{
|
|
return do_test()? 0 : 1;
|
|
}
|