%description:
Test operators in NED, with constant (non-volatile) parameters.

%file: test.ned

simple Test
{
    parameters:
        @isNetwork(true);
        double p00 = -3;      // unary minus or negative constant
        double p01 = -(4+1);  // unary minus

        double p02 = int(!true);  // negation
        double p03 = int(!false); // negation

        double p06 = ~3;    // bitwise complement (result should be positive)
        double p07 = 12^3;  // power of
        double p08 = 12*3;  // multiply
        double p09 = 12/3;  // divide
        double p10 = 12%5;  // modulus
        double p11 = 12+3;  // add
        double p12 = 12-3;  // subtract

        double p13 = 10<<2; // bitwise shifting
        double p14 = 10>>2; // bitwise shifting

        double p15 = 10&3;  // bitwise and
        double p16 = 10|3;  // bitwise or
        double p17 = 10#3;  // bitwise xor

        double p18 = int(8==3); // equal
        double p19 = int(8==8); // equal

        double p20 = int(8!=3); // not equal
        double p21 = int(8!=8); // not equal

        double p22 = int(8>3);  // greater
        double p23 = int(3>8);  // greater
        double p24 = int(8>8);  // greater

        double p25 = int(8>=3); // greater or equal
        double p26 = int(3>=8); // greater or equal
        double p27 = int(8>=8); // greater or equal

        double p28 = int(8<3);  // less
        double p29 = int(3<8);  // less
        double p30 = int(8<8);  // less

        double p31 = int(8<=3); // less or equal
        double p32 = int(3<=8); // less or equal
        double p33 = int(8<=8); // less or equal

        double p34 = int(true && true);   // logical and
        double p35 = int(true && false);  // logical and
        double p36 = int(false && true);  // logical and
        double p37 = int(false && false); // logical and

        double p38 = int(true || true);   // logical or
        double p39 = int(true || false);  // logical or
        double p40 = int(false || true);  // logical or
        double p41 = int(false || false); // logical or

        double p42 = int(true ## true);   // logical xor
        double p43 = int(true ## false);  // logical xor
        double p44 = int(false ## true);  // logical xor
        double p45 = int(false ## false); // logical xor

        double p46 = (true ? 5 : 2);  // the C/C++ ''inline if''
        double p47 = (false ? 5 : 2); // the C/C++ ''inline if''

        string p48 = "" + "";      // concatenation
        string p49 = "Hello" + ""; // concatenation
        string p50 = "" + "Hello"; // concatenation
        string p51 = "He" + "llo"; // concatenation
}

%file: test.cc

#include <omnetpp.h>

using namespace omnetpp;

namespace @TESTNAME@ {

class Test : public cSimpleModule
{
  public:
    Test() : cSimpleModule(16384) { }
    virtual void activity() override;
};

Define_Module(Test);

void Test::activity()
{
    for (int i=0; i<getNumParams(); i++) {
        EV << par(i).getName() << "=";
        par(i).isNumeric() ? EV << par(i).doubleValue() : EV << par(i).stringValue();
        EV << endl;
    }
    EV << ".\n";
}

}; //namespace

%contains-regex: stdout
p00=-3
p01=-5
p02=0
p03=1
p06=[-]?[0-9eE+.]+
p07=1728
p08=36
p09=4
p10=2
p11=15
p12=9
p13=40
p14=2
p15=2
p16=11
p17=9
p18=0
p19=1
p20=1
p21=0
p22=1
p23=0
p24=0
p25=1
p26=0
p27=1
p28=0
p29=1
p30=0
p31=0
p32=1
p33=1
p34=1
p35=0
p36=0
p37=0
p38=1
p39=1
p40=1
p41=0
p42=0
p43=1
p44=1
p45=0
p46=5
p47=2
p48=
p49=Hello
p50=Hello
p51=Hello
.