static bool test_empty_simple_value() {
emit_test("Does FlattenAndInline set the value to be the flattened "
"simple ExprTree's value on an empty ClassAd?");
classad::ClassAd classad;
classad::ExprTree *expr = Literal::MakeAbsTime();
Value value;
classad::ExprTree *fexpr;
ClassAdUnParser unparser;
string value_string, expr_string, classad_string;
unparser.Unparse(expr_string, expr);
unparser.Unparse(classad_string, &classad);
classad.FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Value", expr_string.c_str());
emit_output_actual_header();
emit_param("Value", value_string.c_str());
if(expr_string.compare(value_string)) {
delete expr; delete fexpr;
FAIL;
}
delete expr; delete fexpr;
PASS;
}
int32_t main(int argc, char* argv[]){
string classad_string = "[ATTR_JOB_ID = 1; b = \"Cardini\"]";
string str = "[ ATTR_JOB_ID = 18; ATTR_TASK_ID = 1; ATTR_VMHB_CPU = 0.000000; ATTR_VMHB_MEMORY = 0.456332; ATTR_VMHB_BYTES_IN = 170008; ATTR_VMHB_BYTES_OUT = 27905; ATTR_VMHB_STATE = \"APP_RUNNING\" ]";
//string str = "[ ATTR_JOB_ID = 2 ]";
ClassAd *classad;
ClassAdParser parser;
classad = parser.ParseClassAd(str, true);
ClassAdPtr ptr(classad);
printf("%d\n", ptr.use_count());
int32_t i;
string state;
ClassAdPtr ptr2(new ClassAd(*ptr.get()));
printf("%d\n", ptr.use_count());
// if(!ptr->EvaluateAttrInt(ATTR_JOB_ID, id.job_id))
if(!ptr->EvaluateAttrString("ATTR_VMHB_STATE",state)) {
printf("error\n");
}
//printf("%s\n",state);
std::cout<<state<<std::endl;
string printed_classad;
ClassAdXMLUnParser xml_unparser;
xml_unparser.SetCompactSpacing(false);
xml_unparser.Unparse(printed_classad, ptr.get());
printf("%s\n", printed_classad.c_str());
printed_classad = "";
ClassAdUnParser unparser;
unparser.Unparse(printed_classad, ptr.get());
printf("%s\n", printed_classad.c_str());
return 0;
}
bool View::
Display( FILE *file )
{
ViewMembers::iterator vmi;
ClassAdUnParser unparser;
Value val;
ClassAd *viewInfo;
string buf;
// display view info
if( !( viewInfo = GetViewInfo( ) ) ) return( false );
unparser.Unparse( buf, viewInfo );
fprintf( file, "%s\n", buf.c_str( ) );
delete viewInfo;
for( vmi = viewMembers.begin( ); vmi != viewMembers.end( ); vmi++ ) {
vmi->GetKey( buf );
vmi->GetRankValue( val );
buf += ": ";
unparser.Unparse( buf, val );
fprintf( file, "%s\n", buf.c_str() );
}
return( true );
}
static bool test_empty_simple_return() {
emit_test("Does FlattenAndInline return true when passed a simple "
"ExprTree on an empty ClassAd?");
classad::ClassAd classad;
classad::ExprTree *expr = Literal::MakeAbsTime();
Value value;
classad::ExprTree *fexpr;
ClassAdUnParser unparser;
string expr_string, classad_string;
unparser.Unparse(expr_string, expr);
unparser.Unparse(classad_string, &classad);
bool flattenResult = classad.FlattenAndInline(expr, value, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_retval("TRUE");
emit_output_actual_header();
emit_retval(tfstr(flattenResult));
if(!flattenResult) {
delete expr; delete fexpr;
FAIL;
}
delete expr; delete fexpr;
PASS;
}
static bool test_empty_simple_flattened_expression() {
emit_test("Does FlattenAndInline set fexpr to NULL when the simple "
"ExprTree is flattened to a single value on an empty ClassAd?");
classad::ClassAd classad;
classad::ExprTree *expr = Literal::MakeAbsTime();
Value value;
classad::ExprTree *fexpr;
ClassAdUnParser unparser;
string value_string, expr_string, classad_string;
unparser.Unparse(expr_string, expr);
unparser.Unparse(classad_string, &classad);
classad.FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("fexpr is NULL", "TRUE");
emit_output_actual_header();
emit_param("fexpr is NULL", tfstr(fexpr == NULL));
if(fexpr != NULL) {
delete expr; delete fexpr;
FAIL;
}
delete expr; delete fexpr;
PASS;
}
void ClassAdJsonUnParser::
UnparseAuxQuoteExpr( std::string &buffer, const ExprTree *expr )
{
ClassAdUnParser unparser;
string expr_str;
unparser.Unparse( expr_str, expr );
UnparseAuxQuoteExpr( buffer, expr_str );
}
bool convertValueToStringValue(const Value value, Value &stringValue)
{
bool could_convert;
time_t rtvalue;
abstime_t atvalue;
string string_representation;
ClassAdUnParser unparser;
switch(value.GetType()) {
case Value::UNDEFINED_VALUE:
stringValue.SetUndefinedValue();
could_convert = false;
break;
case Value::ERROR_VALUE:
stringValue.SetErrorValue();
could_convert = false;
break;
case Value::STRING_VALUE:
stringValue.CopyFrom(value);
could_convert = true;
break;
case Value::CLASSAD_VALUE:
case Value::LIST_VALUE:
case Value::SLIST_VALUE:
case Value::BOOLEAN_VALUE:
case Value::INTEGER_VALUE:
case Value::REAL_VALUE:
unparser.Unparse(string_representation, value);
stringValue.SetStringValue(string_representation);
could_convert = true;
break;
case Value::ABSOLUTE_TIME_VALUE:
value.IsAbsoluteTimeValue(atvalue);
absTimeToString(atvalue, string_representation);
stringValue.SetStringValue(string_representation);
could_convert = true;
break;
case Value::RELATIVE_TIME_VALUE:
value.IsRelativeTimeValue(rtvalue);
relTimeToString(rtvalue, string_representation);
stringValue.SetStringValue(string_representation);
could_convert = true;
break;
default:
could_convert = false; // Make gcc's -Wuninitalized happy
CLASSAD_EXCEPT( "Should not reach here" );
break;
}
return could_convert;
}
ostream& operator<<(ostream &stream, const ExprTree *expr)
{
ClassAdUnParser unparser;
string string_representation;
unparser.Unparse(string_representation, expr);
stream << string_representation;
return stream;
}
static bool test_equivalence_partial_multiple() {
emit_test("Test if the partially flattened and inlined ExprTree is "
"logically equivalent to the original ExprTree after multiple "
"FlattenAndInline calls.");
classad::ClassAd *classad1, *classad2, *classad3;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr1, *fexpr2, *fexpr3;
string classad1_string = "[a = b]";
string classad2_string = "[b = c]";
string classad3_string = "[c = d]";
string expr_string = "a + b - c";
ClassAdParser parser;
classad1 = parser.ParseClassAd(classad1_string, true);
classad2 = parser.ParseClassAd(classad2_string, true);
classad3 = parser.ParseClassAd(classad3_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad1->FlattenAndInline(expr, value, fexpr1);
classad2->FlattenAndInline(fexpr1, value, fexpr2);
classad3->FlattenAndInline(fexpr2, value, fexpr3);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr3);
emit_input_header();
emit_param("ClassAd 1", classad1_string.c_str());
emit_param("ClassAd 2", classad2_string.c_str());
emit_param("ClassAd 3", classad3_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "d + d - d");
emit_param("Flattened and Inlined Expression", "<error:null expr>");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", "'%s'", fexpr_string.c_str());
if(fexpr_string.compare("d + d - d") != MATCH){
delete classad1; delete classad2; delete classad3;
delete expr; delete fexpr1; delete fexpr2; delete fexpr3;
FAIL;
}
delete classad1; delete classad2; delete classad3;
delete expr; delete fexpr1; delete fexpr2; delete fexpr3;
PASS;
}
ostream& operator<<(ostream &stream, Value &value)
{
ClassAdUnParser unparser;
string unparsed_text;
switch (value.valueType) {
case Value::NULL_VALUE:
stream << "(null)";
break;
case Value::ERROR_VALUE:
stream << "error";
break;
case Value::UNDEFINED_VALUE:
stream << "undefined";
break;
case Value::BOOLEAN_VALUE:
if (value.booleanValue) {
stream << "true";
} else {
stream << "false";
}
break;
case Value::INTEGER_VALUE:
stream << value.integerValue;
break;
case Value::REAL_VALUE:
stream << value.realValue;
break;
case Value::LIST_VALUE:
case Value::SLIST_VALUE:
case Value::CLASSAD_VALUE:
case Value::RELATIVE_TIME_VALUE:
case Value::ABSOLUTE_TIME_VALUE: {
unparser.Unparse(unparsed_text, value);
stream << unparsed_text;
break;
}
case Value::STRING_VALUE:
stream << *value.strValue;
break;
default:
break;
}
return stream;
}
string View::
makePartitionSignature( ClassAd *ad )
{
ClassAdUnParser unparser;
ExprListIterator itr;
string signature;
Value value;
ClassAd *oad, *info;
const ExprList *el = NULL;
// stash the old ad from the environment and insert the new ad in
oad = evalEnviron.RemoveRightAd( );
evalEnviron.ReplaceRightAd( ad );
if( !( info = evalEnviron.GetLeftAd( ) ) ) {
CLASSAD_EXCEPT( "internal error: view doesn't have view info" );
}
vector<ExprTree*> exprs;
if( !info->EvaluateAttr( ATTR_PARTITION_EXPRS, value ) ||
!value.IsListValue( el ) ) {
evalEnviron.RemoveRightAd( );
return( string( "" ) );
}
el->GetComponents( exprs );
if( exprs.size( ) == 0 ) {
evalEnviron.RemoveRightAd( );
return( string( "" ) );
}
// go through the expression list and form a value vector
signature = "<|";
itr.Initialize( el );
while( !itr.IsAfterLast( ) ) {
itr.CurrentValue( value );
unparser.Unparse( signature, value );
signature += "|";
itr.NextExpr( );
}
signature += ">";
// put the old ad back in the environmnet
evalEnviron.RemoveRightAd( );
evalEnviron.ReplaceRightAd( oad );
// return the computed signature
return( signature );
}
static bool test_equivalence_complex_list() {
emit_test("Test if the partially flattened and inlined ExprTree is "
"logically equivalent to the original complex expression list "
"ExprTree.");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = b; b = 2; c = d;]";
string expr_string = "{a, b, c, d, true || false, true && false, 10 + a,"
"10 - a, 10 * a, 10 / a}";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "undefined");
emit_param("Flattened and Inlined Expression", "{ 2,2,d,d,true,false,12,"
"8,20,5 }");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(fexpr_string.compare("{ 2,2,d,d,true,false,12,8,20,5 }") != MATCH){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
char *
classad_unparse (classad_context cad)
{
if (cad == NULL) return NULL;
std::string res_s;
char *res_c;
ClassAd *ad = (ClassAd *)cad;
ClassAdUnParser unparser;
unparser.Unparse(res_s, ad);
if (res_s.size() > 0)
{
res_c = strdup(res_s.c_str());
}
// res_c == NULL on error.
return (res_c);
}
static bool test_equivalence_nested_loop_classad() {
emit_test("Test if FlattenAndInline handles a nested classad with a "
"loop");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = [b = a]]";
string expr_string = "a";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
classad_string.clear();
unparser.Unparse(classad_string, classad);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "undefined");
emit_param("Flattened and Inlined Expression", "<error:null expr>");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(fexpr == NULL && value_string.compare("undefined") != MATCH){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
static bool test_equivalence_partial_complex_boolean() {
emit_test("Test if the partially flattened and inlined ExprTree is "
"logically equivalent to the original complex boolean ExprTree.");
emit_comment("This expression could be further reduced to 'g'");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = true; b = false; c = a || b; d = a && b; "
"e = c && !d; f = !c; g = h]";
string expr_string = "!e && c || g ";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "undefined");
emit_param("Flattened and Inlined Expression", "false || h");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(fexpr_string.compare("false || h") != MATCH){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
static bool test_equivalence_partial_arithmetic_end() {
emit_test("Test if the partially flattened and inlined ExprTree is "
"logically equivalent to the original arithmetic ExprTree with an "
"inlined value in the end.");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = b; b = 1; c = f]";
string expr_string = "a + b + c";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
string value2_string, fexpr2_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "undefined");
emit_param("Flattened and Inlined Expression", "2 + f");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(fexpr_string.compare("2 + f") != MATCH){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
//Difference between Flatten and FlattenAndInline:
// Flatten: 6 + a - 5
// FlattenAndInline: 6 + f - 5
static bool test_equivalence_partial_arithmetic_constants() {
emit_test("Test if the partially flattened and inlined ExprTree is "
"logically equivalent to the original arithmetic ExprTree that has "
"constants.");
emit_comment("This expression could be further reduced to '1 + f'");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = f; b = c; c = 1]";
string expr_string = "a + b + (c*5) - (25*b/5))";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
string value2_string, fexpr2_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "undefined");
emit_param("Flattened and Inlined Expression", "6 + f - 5");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(fexpr_string.compare("6 + f - 5") != MATCH){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
static bool test_equivalence_nested_classad() {
emit_test("Test if the partially flattened and inlined ExprTree is "
"logically equivalent to the original ExprTree when using a nested "
"classad.");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = [b = c]; c = 1]";
string expr_string = "a";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = classad->Lookup("a");
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "undefined");
emit_param("Flattened and Inlined Expression", "[ b = 1 ]");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(fexpr_string.compare("[ b = 1 ]") != MATCH){
delete classad; delete fexpr;
FAIL;
}
delete classad; delete fexpr;
PASS;
}
static bool test_equivalence_full_complex_boolean() {
emit_test("Test if the fully flattened and inlined ExprTree is logically "
"equivalent to the original complex boolean ExprTree.");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = true; b = false; c = a || b; d = a && b; "
"e = c && !d; f = !c]";
string expr_string = "e || !c";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "true");
emit_param("Flattened and Inlined Expression", "<error:null expr>");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(value_string.compare("true") != MATCH){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
static bool test_equivalence_no_change() {
emit_test("Test if the flattened and inlined ExprTree is logically "
"equivalent to the original ExprTree when the flattening and inlining "
"does nothing.");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = 1]";
string expr_string = "f";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "undefined");
emit_param("Flattened and Inlined Expression", "f");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(!expr->SameAs(fexpr)){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
bool
MakeSignature( const ClassAd *ad, const References &refs, string &sig )
{
References::iterator itr;
ExprTree *expr;
Value val;
ClassAdUnParser unp;
sig = "";
for( itr=refs.begin( ); itr!= refs.end( ); itr++ ) {
if((expr=ad->Lookup(*itr))&&expr->GetKind()==ExprTree::LITERAL_NODE) {
unp.Unparse( sig, expr );
} else {
return( false );
}
sig += ":";
}
return( true );
}
static bool test_equivalence_full_arithmetic_constants() {
emit_test("Test if the fully flattened and inlined ExprTree is logically "
"equivalent to the original arithmetic ExprTree that has constants.");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = b; b = c; c = 1]";
string expr_string = "a + b + (c*5) - (25*b/5))";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string, fexpr_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
unparser.Unparse(fexpr_string, fexpr);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Flattened and Inlined Value", "2");
emit_param("Flattened and Inlined Expression", "<error:null expr>");
emit_output_actual_header();
emit_param("Flattened and Inlined Value", value_string.c_str());
emit_param("Flattened and Inlined Expression", fexpr_string.c_str());
if(value_string.compare("2") != MATCH){
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
static bool test_non_empty_simple_flattened_expression() {
emit_test("Does FlattenAndInline set fexpr to NULL when the simple "
"ExprTree is flattened to a single value on a non-empty ClassAd?");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = 1; b = \"Cardini\"]";
string expr_string = "a";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("fexpr is NULL", "TRUE");
emit_output_actual_header();
emit_param("fexpr is NULL", tfstr(fexpr == NULL));
if(fexpr != NULL) {
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
static bool test_non_empty_simple_value() {
emit_test("Does FlattenAndInline set the value to be the flattened "
"simple ExprTree's value on a non-empty ClassAd?");
classad::ClassAd *classad;
classad::ExprTree *expr;
Value value;
classad::ExprTree *fexpr;
string classad_string = "[a = 1; b = \"Cardini\"]";
string expr_string = "a";
ClassAdParser parser;
classad = parser.ParseClassAd(classad_string, true);
expr = parser.ParseExpression(expr_string);
ClassAdUnParser unparser;
string value_string;
classad->FlattenAndInline(expr, value, fexpr);
unparser.Unparse(value_string, value);
emit_input_header();
emit_param("ClassAd", classad_string.c_str());
emit_param("ExprTree", expr_string.c_str());
emit_param("Value", "");
emit_param("ExprTree", "NULL");
emit_output_expected_header();
emit_param("Value", "1");
emit_output_actual_header();
emit_param("Value", value_string.c_str());
if(value_string.compare("1")) {
delete classad; delete expr; delete fexpr;
FAIL;
}
delete classad; delete expr; delete fexpr;
PASS;
}
