Use LTTngUSTLogger logger plugin in logtest regression test

[deliverable/titan.core.git] / regression_test / XML / macros.ttcnin

/******************************************************************************
 * Copyright (c) 2000-2016 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Balasko, Jeno
 *   Baranyi, Botond
 *   Raduly, Csaba
 *
 ******************************************************************************/
/*
 * Note: this file needs to be included *after* this bit:
 *
 * module whatever {
 *   modulepar boolean verbose := false;
 */

/* The following macros output error/warning messages in the "GCC format",
 * which can be parsed by Eclipse.
 */

// A TODO in the output
#define NOT_YET \
    log(": warning: not implemented"); \
    setverdict(inconc)

// Output a failure or (optionally) success message in a format
// that can be parsed by Eclipse (GCC format).
// This requires a variable or module parameter called "verbose".
#define COMPARE(actual,expected) if ( match(actual,expected) ) { \
    if(verbose) { log( expected, "\t  matches OK" ); } \
    setverdict(pass); \
} else { \
    log(": fail: G0T ", actual  ); \
    log(": fail: EXP ", expected); \
    setverdict(fail,  match(actual,expected)); \
}

#ifndef NO_XER
import from converter all;

// Run an encode and compare the result
#define CHECK_METHOD(method,input,expected) { \
	var octetstring u8 := method(input); \
	var universal charstring actual; \
	var integer retval := o2u("UTF-8", u8, actual); \
	if (retval!=0) { setverdict(fail, "Conversion failed: ", retval) } \
	COMPARE(actual, expected); \
}

// Run a decode and compare the result
#define CHECK_DECODE(method,input,type,expected) { \
    var octetstring bytes; \
    var integer retval := u2o("UTF-8", input, bytes); \
	if (retval!=0) { setverdict(fail, "Conversion failed: ", retval) } \
	var type actual := method(bytes); \
	COMPARE(actual, expected); \
}

// Run an encode or decode expecting a DTE and compare the error message
#define CHECK_METHOD_ERROR(method,input,type,expected_error) { \
  @try { \
	  var type res := method(input); \
    setverdict(fail, "Expected conversion error: ", expected_error); \
  } @catch(err) { \
	  if (match(err, expected_error)) { setverdict(pass); } \
    else { setverdict(fail, "Wrong error message! EXPECTED: ", expected_error, ", GOT: ", err); } \
  } \
}

// Run a decode and check that it failed
#define CHECK_DECODE_FAIL(method,input,type) { \
    var octetstring bytes; \
    var integer retval := u2o("UTF-8", input, bytes); \
	if (retval!=0) { setverdict(fail, "Conversion failed: ", retval) } \
	var type actual; \
	retval := method(bytes, actual); \
	if (retval!=1) { log(": fail: Got ", retval, " instead of failure (1)"); \
	setverdict(fail, "Expected failure (1), got: ", retval) } \
}

// Run a decode and check that it failed, but compare the result of the decode
#define CHECK_DECODE_FAIL_AND_COMPARE(method,input,type,expected) { \
    var octetstring bytes; \
    var integer retval := u2o("UTF-8", input, bytes); \
	if (retval!=0) { setverdict(fail, "Conversion failed: ", retval) } \
	var type actual; \
	retval := method(bytes, actual); \
	if (retval!=1) { log(": fail: Got ", retval, " instead of failure (1)"); \
	setverdict(fail, "Expected failure (1), got: ", retval) } \
	COMPARE(actual, expected); \
}

/*
Check both decodes.
This has the disadvantage that the line number will be the same.
Figuring out which decode failed may need some guesswork.
But chances are, both will fail at the same time :)
*/
#define CHECK_DECODE2(typesuffix, input, type, expected) \
	CHECK_DECODE(cxer_dec_ ## typesuffix, input, type, expected); \
	CHECK_DECODE(bxer_dec_ ## typesuffix, input, type, expected)

// Ease migration from CHECK_ENCODE :)
#define CHECK_DECODE3(typesuffix, input, expected) \
    CHECK_DECODE(cxer_dec_ ## typesuffix, input, Asn_ ## typesuffix, expected); \
    CHECK_DECODE(bxer_dec_ ## typesuffix, input, Asn_ ## typesuffix, expected)


#define DECLARE_XER_ENCODERS(Type, suffix) \
  external function bxer_enc_ ## suffix(in Type par) return octetstring with { \
    extension "prototype(convert) encode (XER:XER_BASIC) errorbehavior(ALL:ERROR)" } \
  external function cxer_enc_ ## suffix(in Type par) return octetstring with { \
    extension "prototype(convert) encode (XER:XER_CANONICAL) errorbehavior(ALL:ERROR)" } \
  external function bxer_dec_ ## suffix(in octetstring par) return Type with { \
    extension "prototype(convert) decode (XER:XER_BASIC) errorbehavior(ALL:ERROR)" } \
  external function cxer_dec_ ## suffix(in octetstring par) return Type with { \
    extension "prototype(convert) decode (XER:XER_CANONICAL) errorbehavior(ALL:ERROR)" }


#define DECLARE_EXER_ENCODERS(Type, suffix) \
  external function exer_enc_ ## suffix(in Type par) return octetstring with { \
    extension "prototype(convert) encode (XER:XER_EXTENDED) errorbehavior(ALL:ERROR)" } \
  external function exer_dec_ ## suffix(in octetstring par) return Type with { \
    extension "prototype(convert) decode (XER:XER_EXTENDED) errorbehavior(ALL:ERROR)" } \

// Decoder which degrades all decoding errors to warnings to avoid DTE.
// Using prototype(backtrack) to have a return value to check.
#define DECLARE_EXER_WARNING_DECODER(Type, suffix) \
  external function exer_decbt_ ## suffix(in octetstring par, out Type t) return integer with { \
    extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)" } \

// Note: errorbehavior(ALL:ERROR) ensures that all enc/dec errors are counted.
// Encdec errors with error behavior of warning or ignore are not counted
// in the final statistics.
#endif


// from isbound test
#define MUST_BOUND(v) if ( isvalue(v) ) { \
    if (verbose){ log( #v & "\t  bound OK" ); } \
    setverdict(pass); \
} else { \
    log( ": fail: " & #v & "=", v, "\tshould be bound" ); \
    setverdict(fail); \
}

#define MUST_UNBOUND(v) if ( isvalue(v) ) { \
    log( ": fail: " & #v & "=", v, "\tshould be unbound" ); \
    setverdict(fail); \
} else { \
    if (verbose){ log( #v & "\tunbound OK" ); } \
    setverdict(pass); \
}

/* A hack for two-element inline templates */
#define MUST_BOUND2(v,w) if ( isvalue(v,w) ) { \
    if (verbose){ log( #v & #w & "\t  bound OK" ); } \
    setverdict(pass); \
} else { \
    log( ": fail: " & #v & #w & "=", v,w, "\tshould be bound" ); \
    setverdict(fail); \
}

#define MUST_UNBOUND2(v,w) if ( isvalue(v,w) ) { \
    log( ": fail: " & #v & #w & "=", v,w, "\tshould be unbound" ); \
    setverdict(fail); \
} else { \
    if (verbose){ log( #v & #w & "\tunbound OK" ); } \
    setverdict(pass); \
}