void
test (void)
{
int i, j, *res = correct_results;
for (i = 0; i < 8; i++)
{
float arg0 = args[i];
for (j = 0; j < 8; j++)
{
float arg1 = args[j];
if (feq (arg0, arg1) != *res++)
abort ();
if (fne (arg0, arg1) != *res++)
abort ();
if (flt (arg0, arg1) != *res++)
abort ();
if (fge (arg0, arg1) != *res++)
abort ();
if (fgt (arg0, arg1) != *res++)
abort ();
if (fle (arg0, arg1) != *res++)
abort ();
}
}
}
void diffuse_vector(TriMesh *themesh, std::vector<T> &field, float sigma)
{
themesh->need_normals();
themesh->need_pointareas();
themesh->need_neighbors();
int nv = themesh->vertices.size();
dprintf("\rSmoothing vector field... ");
timestamp t = now();
float invsigma2 = 1.0f / sqr(sigma);
vector<T> flt(nv);
AccumVec<T> a(field);
#pragma omp parallel
{
// Thread-local flags
vector<unsigned> flags(nv);
unsigned flag_curr = 0;
#pragma omp for
for (int i = 0; i < nv; i++)
diffuse_vert_field(themesh, flags, flag_curr,
a, i, invsigma2, flt[i]);
} // #pragma omp parallel
field = flt;
dprintf("Done. Filtering took %f sec.\n", now() - t);
}
int main(int argc, char *args[])
{
g=argc;
dec(argc);
hex(argc);
flt(argc);
oct(argc);
return 0;
}
/**
* @brief test
*/
static void test()
{
Image img(1, 512, 512, 3);
img = 1.0f;
FilterCrop flt(Vec2i(100, 100), Vec2i(200, 200));
Image *out = flt.Process(Single(&img), NULL);
out->Write("test_crop_2d_output.pfm");
}
/**
* @brief RGBtoLogLuv
* @param imgIn
* @param imgOut
* @param bDirect
* @return
*/
static Image *RGBtoLogLuv(Image *imgIn, Image *imgOut,
bool bDirect)
{
ColorConvRGBtoXYZ csXYZ;
ColorConvXYZtoLogLuv csLogLuv;
FilterColorConv flt(NULL, bDirect);
flt.insertColorConv(&csXYZ);
flt.insertColorConv(&csLogLuv);
return flt.Process(Single(imgIn), imgOut);
}
/**
* @brief ExectueCIELABtoRGB
* @param imgIn
* @param imgOut
* @param bDirect
* @return
*/
static Image *CIELABtoRGB(Image *imgIn, Image *imgOut,
bool bDirect)
{
ColorConvRGBtoXYZ csXYZ;
ColorConvXYZtoCIELAB csCIELAB;
FilterColorConv flt(NULL, bDirect);
flt.insertColorConv(&csCIELAB);
flt.insertColorConv(&csXYZ);
return flt.Process(Single(imgIn), imgOut);
}
int main(int argc,char **argv)
{
std::string captured;
try {
cppcms::service srv(argc,argv);
write_tests = srv.settings().get("test.write",false);
booster::intrusive_ptr<cppcms::application> async = new async_test(srv);
srv.applications_pool().mount( async, cppcms::mount_point("/async") );
srv.applications_pool().mount( cppcms::applications_factory<sync_test>(), cppcms::mount_point("/sync"));
srv.after_fork(submitter(srv));
cppcms::copy_filter flt(std::cerr); // record the log
srv.run();
captured = flt.detach(); // get the log
}
catch(std::exception const &e) {
std::cerr << e.what() << std::endl;
return EXIT_FAILURE;
}
size_t pos = 0;
while((pos=captured.find("Timeout on connection",pos))!=std::string::npos) {
pos+=10;
count_timeouts++;
}
if(
write_tests ?
(
async_bad_count != 2
|| sync_bad_count != 2
|| count_timeouts != 4
|| above_15 != 2
|| below_10 != 2
)
:
(
!eof_detected
|| count_timeouts != 5
)
)
{
print_count_report(std::cerr);
std::cerr << "Failed" << std::endl;
return EXIT_FAILURE;
}
print_count_report(std::cout);
if(!run_ok ) {
std::cerr << "Python script failed" << std::endl;
return EXIT_FAILURE;
}
std::cout << "Ok" << std::endl;
return EXIT_SUCCESS;
}
void CheckGetSized(int destsize,
int valsize,
int correct_retval,
const unsigned char* correct_result)
{
llvm::APFloat flt(llvm::APFloat::x87DoubleExtended, GetParam().ascii);
yasm::Bytes result;
result.resize(destsize);
result.setLittleEndian();
yasm::NumericOutput num_out(result);
num_out.setSize(valsize);
num_out.OutputFloat(flt);
for (int i=0; i<destsize; ++i)
EXPECT_EQ(correct_result[i], result[i]);
}
HRESULT GetFilter_old(dimension_t dimension, short index, BSTR* filter)
{
std::string szFG;
std::string szFV;
int newIndex = offset_to_new_index_(atFilter, dimension, index);
XXGetFilterEx_(dimension, newIndex, &szFG, &szFV);
CString flt(szFG.c_str()); // +1
flt += strFilterSeparator; // +2
flt += szFV.c_str(); // +1
CComBSTR bFilter(flt); // +1
*filter = bFilter.Detach();
return S_OK;
}
/*==============================================================================
* FUNCTION: DfaTest::testMeetSize
* OVERVIEW: Test meeting IntegerTypes with various other types
*============================================================================*/
void DfaTest::testMeetSize()
{
IntegerType i32(32, 1);
SizeType s32(32);
SizeType s16(16);
FloatType flt(32);
VoidType v;
bool ch = false;
Type *res = s32.meetWith(&i32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost1;
ost1 << res;
std::string actual(ost1.str());
std::string expected("i32");
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
res = s32.meetWith(&s16, ch, false);
CPPUNIT_ASSERT(ch == false);
#if 0
// There is a known failure here; to show the warning, use ErrLogger
Boomerang::get()->setLogger(new ErrLogger);
res = s16.meetWith(&flt, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost2;
ost2 << res;
actual = ost2.str();
expected = "union";
CPPUNIT_ASSERT_EQUAL(expected, actual);
#endif
ch = false;
res = s16.meetWith(&v, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost3;
ost3 << res;
actual = ost3.str();
expected = "16";
CPPUNIT_ASSERT_EQUAL(expected, actual);
}
/*==============================================================================
* FUNCTION: DfaTest::testMeetUnion
* OVERVIEW: Test meeting IntegerTypes with various other types
*============================================================================*/
void DfaTest::testMeetUnion()
{
UnionType u1;
IntegerType i32(32, 1);
IntegerType j32(32, 0);
IntegerType u32(32, -1);
FloatType flt(32);
u1.addType(&i32, "bow");
u1.addType(&flt, "wow");
std::ostringstream ost1;
ost1 << u1.getCtype();
std::string actual(ost1.str());
std::string expected("union { int bow; float wow; }");
CPPUNIT_ASSERT_EQUAL(expected, actual);
bool ch = false;
Type *res = u1.meetWith(&j32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost2;
ost2 << res->getCtype();
actual = ost2.str();
expected = "union { int bow; float wow; }";
CPPUNIT_ASSERT_EQUAL(expected, actual);
res = u1.meetWith(&j32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost3;
ost3 << u1.getCtype();
actual = ost3.str();
expected = "union { int bow; float wow; }";
CPPUNIT_ASSERT_EQUAL(expected, actual);
// Note: this test relies on the int in the union having signedness 1
res = u1.meetWith(&u32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost4;
ost4 << u1.getCtype();
actual = ost4.str();
expected = "union { /*signed?*/int bow; float wow; }";
CPPUNIT_ASSERT_EQUAL(expected, actual);
}
ConvLayer::ConvLayer(int filters, ivec inshape, ivec fshape, int stride,
ConvNet* net)
{
InShape = inshape;
Stride = stride;
Fshape = fshape;
OutShape = outshape(InShape, Fshape, Stride, filters);
Steps = calcsteps(InShape, Fshape, Stride, filters);
dmatrix3 refE(OutShape[0], dmatrix2(OutShape[1], dvec(OutShape[2], 0.0)));
refE.swap(Excitations);
dmatrix3 refA(OutShape[0], dmatrix2(OutShape[1], dvec(OutShape[2], 0.0)));
refA.swap(Activations);
dmatrix3 refErr(OutShape[0],dmatrix2(OutShape[1],dvec(OutShape[2], 0.0)));
refErr.swap(Errors);
dmatrix4 flt(filters,dmatrix3(InShape[0],
dmatrix2(Fshape[0],dvec(Fshape[1], 0.5))));
flt.swap(Filters);
Brain = net;
}
WEXPORT WFileDialog::WFileDialog( WWindow* parent, unsigned res_idx )
: _parent( parent ) {
/***************************/
static char buffer[ 512 ];
WResStr flt( res_idx );
const char * filter;
unsigned i = 0;
filter = flt;
do {
if( filter[i] == REPCHAR ) {
buffer[ i ] = '\0';
} else {
buffer[ i ] = filter[ i ];
}
} while( filter[ i++ ] );
_fileName = new char[ WFileBufSize ];
makeDialog( buffer );
}
void KateFileSelector::readConfig(TDEConfig *config, const TQString & name)
{
dir->setViewConfig( config, name + ":view" );
dir->readConfig(config, name + ":dir");
dir->setView( KFile::Default );
dir->view()->setSelectionMode(KFile::Extended);
config->setGroup( name );
// set up the toolbar
setupToolbar( config );
cmbPath->setMaxItems( config->readNumEntry( "pathcombo history len", 9 ) );
cmbPath->setURLs( config->readPathListEntry( "dir history" ) );
// if we restore history
if ( config->readBoolEntry( "restore location", true ) || kapp->isRestored() ) {
TQString loc( config->readPathEntry( "location" ) );
if ( ! loc.isEmpty() ) {
// waitingDir = loc;
// TQTimer::singleShot(0, this, TQT_SLOT(initialDirChangeHack()));
setDir( loc );
}
}
// else is automatic, as cmpPath->setURL is called when a location is entered.
filter->setMaxCount( config->readNumEntry( "filter history len", 9 ) );
filter->setHistoryItems( config->readListEntry("filter history"), true );
lastFilter = config->readEntry( "last filter" );
TQString flt("");
if ( config->readBoolEntry( "restore last filter", true ) || kapp->isRestored() )
flt = config->readEntry("current filter");
filter->lineEdit()->setText( flt );
slotFilterChange( flt );
autoSyncEvents = config->readNumEntry( "AutoSyncEvents", 0 );
}
/**
* @brief execute
* @param img
* @param corners
*/
void execute(Image *img, std::vector< Eigen::Vector2f > *corners)
{
if(img == NULL || corners == NULL) {
return;
}
if(img->channels == 1) {
bLum = false;
lum = img;
} else {
bLum = true;
lum = FilterLuminance::execute(img, lum, LT_CIE_LUMINANCE);
}
corners->clear();
std::vector< Eigen::Vector3f > corners_w_quality;
//filter the input image
FilterGaussian2D flt(sigma);
lum_flt = flt.Process(Single(lum), NULL);
//"rasterizing" a circle
std::vector< int > x, y;
int radius_sq = radius * radius;
for(int i=-radius; i<=radius; i++) {
int i_sq = i * i;
for(int j=-radius; j<=radius; j++) {
if((j == 0) && (i == 0)) {
continue;
}
int r_sq = i_sq + j * j;
if(r_sq <= radius_sq){
x.push_back(j);
y.push_back(i);
}
}
}
int width = lum_flt->width;
int height = lum_flt->height;
float C = float(x.size());
float t = 0.05f; //depends on image noise
float g = C * 0.5f; //geometric constant for determing corners
Image R(1,width, height, 1);
R.setZero();
for(int i = radius; i < (height - radius - 1); i++) {
for(int j = radius; j < (width - radius - 1); j++) {
int ind = i * width + j;
float sum = 0.0f;
for(unsigned int k = 0; k < x.size(); k++) {
int ind_c = (i + y[k]) * width + (j + x[k]);
float diff = (lum_flt->data[ind_c] - lum_flt->data[ind]) / t;
float diff_2 = diff * diff;
float diff_4 = diff_2 * diff_2;
float diff_6 = diff_4 * diff_2;
sum += expf(-diff_6);
}
if(sum < g) {
R.data[ind] = g - sum;
}
}
}
//non-maximal supression
int side = radius_maxima * 2 + 1;
int *indices = new int [side * side];
for(int i = radius_maxima; i< (height - radius_maxima - 1); i++) {
int tmp = i * width;
for(int j = radius_maxima; j < (width - radius_maxima - 1); j++) {
int ind = tmp + j;
if(R.data[ind] <= 0.0f) {
continue;
}
indices[0] = ind;
int counter = 1;
for(int k = -radius_maxima; k <= radius_maxima; k++) {
int yy = CLAMP(i + k, height);
for(int l = -radius_maxima; l <= radius_maxima; l++) {
if((l == 0) && (k == 0)) {
continue;
}
int xx = CLAMP(j + l, width);
ind = yy * width + xx;
if(R.data[ind]>0.0f){
indices[counter] = ind;
counter++;
}
}
}
//are other corners near-by?
if(counter > 1) {
//find the maximum value
float R_value = R.data[indices[0]];
int index = 0;
for(int k = 1; k < counter; k++){
if(R.data[indices[k]] > R_value) {
R_value = R.data[indices[k]];
index = k;
}
}
if(index == 0){
corners_w_quality.push_back(Eigen::Vector3f (float(j), float(i), 1.0f) );
}
} else {
corners_w_quality.push_back(Eigen::Vector3f (float(j), float(i), 1.0f) );
}
}
}
sortCornersAndTransfer(&corners_w_quality, corners);
if(indices != NULL) {
delete[] indices;
indices = NULL;
}
}
// Returns a random float between min and max,
// default parameters are FLT_MIN and FLT_MAX
float RNG::randFloat(float min, float max){
rnd = std::default_random_engine(rd());
std::uniform_real_distribution<float> flt(min,max);
return flt(rnd);
};
int main(int argc, char *argv[])
{
std::string img_str;
if(argc == 2) {
img_str = argv[1];
} else {
img_str = "../data/input/tommaseo_statue.png";
}
printf("Reading an image...");
pic::Image img;
img.Read(img_str, pic::LT_NOR_GAMMA);
printf("Ok\n");
printf("Is it valid? ");
if(img.isValid()) {
printf("Ok\n");
printf("Estimated noise:\n");
float *noise = pic::FilterNoiseEstimation::getNoiseEstimation(&img, NULL);
for(int i = 0; i < img.channels; i++) {
printf("Channel i-th: %f\n", noise[i]);
}
pic::ImageVec input = pic::Single(&img);
pic::Image *output = NULL;
bool bWritten;
std::string name = pic::removeExtension(img_str);
name = pic::removeLocalPath(name);
//the bilateral filter
printf("Filtering the image with a Fast Bilateral filter;\n");
printf("this has sigma_s = 4.0 and sigma_r = 0.05 ... ");
pic::FilterBilateral2DS flt(8.0f, 0.05f);
output = flt.Process(input, output);
//output = pic::FilterBilateral2DAS::execute(&img, output, 8.0f, 0.05f);
printf("Ok!\n");
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "_filtered_bilateral.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
//the median filter
printf("Filtering the image with the Median filter (radius of 3);\n");
pic::FilterMed fltM(7);
output = fltM.Process(input, output);
printf("Ok!\n");
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "_filtered_median.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
//the vector median filter
printf("Filtering the image with the Vector Median filter (radius of 3);\n");
pic::FilterMedVec fltMV(7);
output = fltMV.Process(input, output);
printf("Ok!\n");
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "filtered_median_vec.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
//the non-local means filter
printf("Filtering the image with Non-Local Means filter;\n");
pic::FilterNonLocalMeansF fltNLM(31, 5, 0.05f);
output = fltNLM.Process(input, output);
printf("Ok!\n");
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "_filtered_non_local_means.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
//the Anisotropic Diffusion
printf("Filtering the image with the Anisotropic Diffusion;\n");
printf("this has sigma_s = 4.0 and sigma_r = 0.05 ... ");
output = pic::FilterAnsiotropicDiffusion::execute(input, output, 8.0f, 0.05f);
printf("Ok!\n");
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "_filtered_anisotropic_diffusion.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
//the Guided Filter
printf("Filtering the image with the Guided filter...");
pic::FilterGuided fltG;
output = fltG.Process(input, output);//filtering the image
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "_filtered_guided.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
//WLS
printf("Filtering the image with the WLS filter...");
pic::FilterWLS fltWLS;//creating the filter
output = fltWLS.Process(input, output);
printf("Ok!\n");
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "_filtered_wls.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
//Kuwahara
printf("Filtering the image with the Kuwahara filter...");
pic::FilterKuwahara fltK(11);
output = fltK.Process(input, output);
printf("Writing the file to disk...");
bWritten = output->Write("../data/output/" + name + "filtered_kuwahara.png", pic::LT_NOR_GAMMA);
if(bWritten) {
printf("Ok\n");
} else {
printf("Writing had some issues!\n");
}
} else {
printf("No it is not a valid file!\n");
}
}
bool
fltAdapter (float a,float b)
{
return flt (f2i (a),f2i (b));
}
int main(int argc, char **argv)
{
cv::Mat ms,md;
cv::Mat cleared, cannyed;
cv::Mat flt(1, 3, 4);
// out names
char clear_noise_tpl[100] = SRCDIR "/%s.clear_noise.bmp";
char canny_tpl[100] = SRCDIR "/%s.canny.bmp";
char split_tpls[][100] = {
SPODIR "/%s.split1.bmp",
SPODIR "/%s.split2.bmp",
SPODIR "/%s.split3.bmp",
SPODIR "/%s.split4.bmp",
SPODIR "/%s.split5.bmp"
};
char buff[100] = {0};
const char *src_path = argc >= 2 ? argv[1] : DEFALT_SRC;
const char *fname_start = strrchr(src_path, '/');
if (fname_start == NULL) fname_start = src_path;
else fname_start = fname_start + 1;
// read src
ms = cv::imread(src_path);
// 转灰
cv::cvtColor(ms, md, CV_BGR2GRAY, 1);
// cv::blur(md, ms, cv::Size(5, 5));
// cv::bilateralFilter(md, md2, 9, 260, 260);
// cv::GaussianBlur(md, md2, cv::Size(5, 5), 60);
// cv::sepFilter2D(md, md2, -1, flt, flt);
// cv::erode(md, md2, cv::Mat(), cv::Point(-1, -1), 2);
// cv::dilate(md2, md, cv::Mat(), cv::Point(-1, -1), 2);
// cv::fastNlMeansDenoising(md, md2, 20);
cv::imwrite("gray.bmp", md);
md = detect_background(md);
cleared = md.clone();
memset(buff, 0, sizeof(buff));
sprintf(buff, clear_noise_tpl, fname_start);
cv::imwrite(buff, cleared);
// 反转
for (int i = 0; i < md.rows; i ++) {
for (int j = 0; j < md.cols; j ++) {
if ((short)md.at<uchar>(i, j) == 0) {
md.at<uchar>(i, j) = 255;
} else {
md.at<uchar>(i, j) = 0;
}
}
}
cv::Canny(md, cannyed, 50, 200, 3);
memset(buff, 0, sizeof(buff));
sprintf(buff, canny_tpl, fname_start);
cv::imwrite(buff, cannyed);
md = cannyed.clone();
std::vector<std::vector<cv::Point> > contours, sorted_contours;
std::vector<cv::Vec4i> hia;
cv::findContours(md, contours, hia, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
// 好像这个连接区域检测效果很差啊
std::cout<< "\n" << contours.size() << "\n";
for (int i = 0; i < contours.size(); i ++) {
std::vector<cv::Point> c1 = contours.at(i);
std::cout<< "" << c1.size() << "," << hia[i] << "\n";
for (int j = 0; j < contours.at(i).size(); j++) {
// std::cout << contours.at(i).at(j) << std::endl;
md.at<uchar>(contours.at(i).at(j)) = 255;
}
}
/*
int nc = 7;
std::vector<std::vector<cv::Point> > ct;
ct.push_back(contours.at(nc));
cv::RotatedRect area = cv::minAreaRect(contours.at(nc));
std::cout<<area.angle<<std::endl;
area.size = cv::Size(area.size.width + 1, area.size.height + 2);
cv::Mat mask = cv::Mat::zeros(ms.rows, ms.cols, CV_8UC1);
cv::drawContours(mask, ct, -1, cv::Scalar(255), CV_FILLED);
cv::Rect drect = area.boundingRect();
cv::rectangle(mask, drect, cv::Scalar(255, 0, 0), 2);
cv::Mat chimg = getRotatedImage(nobg, area);
*/
// sort
sorted_contours = sort_contours(contours, SPICNT);
std::cout<< "\n" << sorted_contours.size() << "\n";
for (int i = 0; i < sorted_contours.size(); i ++) {
std::vector<cv::Point> c1 = sorted_contours.at(i);
std::cout<< "sorted: " << c1.size() << ", " << hia[i] << "\n";
}
for (int i = 0; i < sorted_contours.size(); i ++) {
cv::RotatedRect area = cv::minAreaRect(sorted_contours.at(i));
area.size = cv::Size(area.size.width + 1, area.size.height + 2);
cv::Mat chimg = getRotatedImage(cleared, area);
memset(buff, 0, sizeof(buff));
sprintf(buff, split_tpls[i], fname_start);
std::cout<<buff<<std::endl;
cv::imwrite(buff, chimg);
}
cv::imwrite("graymy.bmp", md);
return 0;
}
/*==============================================================================
* FUNCTION: DfaTest::testMeetInt
* OVERVIEW: Test meeting IntegerTypes with various other types
*============================================================================*/
void DfaTest::testMeetInt()
{
IntegerType i32(32, 1);
IntegerType j32(32, 0);
IntegerType u32(32, -1);
IntegerType xint(0);
IntegerType j16(16, 0);
SizeType s32(32);
SizeType s64(64);
FloatType flt(32);
PointerType pt(&flt);
VoidType v;
bool ch = false;
i32.meetWith(&i32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost1;
ost1 << &i32;
std::string actual(ost1.str());
std::string expected("i32");
CPPUNIT_ASSERT_EQUAL(expected, actual);
i32.meetWith(&j32, ch, false);
CPPUNIT_ASSERT(ch == false);
j32.meetWith(&i32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost2;
ost2 << &i32;
actual = ost2.str();
expected = "i32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
j32.setSigned(0);
j32.meetWith(&v, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost2a;
ost2a << &j32;
actual = ost2a.str();
expected = "j32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
j32.meetWith(&u32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost3;
ost3 << &j32;
actual = ost3.str();
expected = "u32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
u32.meetWith(&s32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost4;
ost4 << &u32;
actual = ost4.str();
expected = "u32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
u32.meetWith(&s64, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost5;
ost5 << &u32;
actual = ost5.str();
expected = "u64";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
Type *res = i32.meetWith(&flt, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost6;
ost6 << res;
actual = ost6.str();
expected = "union";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
res = i32.meetWith(&pt, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost7;
ost7 << res;
actual = ost7.str();
expected = "union";
CPPUNIT_ASSERT_EQUAL(expected, actual);
}
