def test4(self, debug=1):
program = """
layout L2_def {
fields { DA : 48; SA : 48; }
}
layout L9_def {
fields { type : 5; three_bits : 3; }
}
L2_def L2_hdr;
L9_def L9_hdr;
parser start { extract ( L2_hdr ) ;
return DO_L9 ;
}
parser DO_L9 { extract ( L9_hdr ) ;
return P4_PARSING_DONE ;
}
"""
pkt = [i for i in range(20)]
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
self.assert_(err == "", "Saw parse runtime err:" + str(err))
self.assert_(num_bytes_used == 13, "Expected 13 bytes consumed, Saw %d." % num_bytes_used)
self.check_field(p4, "L2_hdr.DA", 0x102030405)
self.check_field(p4, "L2_hdr.SA", 0x60708090A0B)
self.check_field(p4, "L9_hdr.type", 1)
self.check_field(p4, "L9_hdr.three_bits", 4)
def test8(self, debug=1):
program = """
layout L2_def { fields { type0: 8; } }
layout L3_def { fields { jjj: 8; } }
layout Type_0 { fields { type1: 8; } }
layout Type_1 { fields { four: 32; } }
L2_def L2_hdr;
L3_def L3_hdr[3];
Type_0 Type_0_hdr;
Type_1 Type_1_hdr;
parser start {
extract ( L2_hdr ) ; /* 0 */
extract ( L3_hdr[0] ) ; /* 1 */
extract ( L3_hdr[1] ) ; /* 2 */
return switch ( current(4,12), latest.jjj, L2_hdr.type0, L3_hdr[1].jjj )
/* 304 02 00 02 = 12952141826 */
{ 0 : GET_TYPE0 ;
1, 3 mask 7 : P4_PARSING_DONE ;
0x304020002 : GET_TYPE1 ;
default : GET_TYPE0 ;
}
}
parser GET_TYPE0 { extract ( Type_0_hdr ) ;
return P4_PARSING_DONE ;
}
parser GET_TYPE1 { extract ( Type_1_hdr ) ;
return P4_PARSING_DONE ;
}
"""
exp_bytes_used = 7
pkt = [i for i in range(8)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
self.assert_(err == "", "Saw parse runtime err:" + str(err))
self.assert_(
num_bytes_used == exp_bytes_used,
"Expected %d bytes consumed, Saw %d." % (exp_bytes_used, num_bytes_used),
)
self.check_field(p4, "L2_hdr.type0", 0x0)
self.check_field(p4, "L3_hdr[0].jjj", 0x1)
self.check_field(p4, "L3_hdr[1].jjj", 0x2)
self.check_field(p4, "Type_1_hdr.four", 0x3040506)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
def test6(self, debug=1):
program = """
layout L2_def {
fields { DA : 48; SA : 48; }
}
L2_def L2_hdr[5];
parser start { extract ( L2_hdr[0] ) ;
return GET_L2_1 ;
}
parser GET_L2_1 { extract ( L2_hdr[next] ) ;
return GET_L2_2 ;
}
parser GET_L2_2 { extract ( L2_hdr[2] ) ;
return GET_L2_3 ;
}
parser GET_L2_3 { extract ( L2_hdr[next] ) ;
return GET_L2_4 ;
}
parser GET_L2_4 { extract ( L2_hdr[4] ) ;
return P4_PARSING_DONE ;
}
"""
exp_bytes_used = 5 * 12
pkt = [i for i in range(60)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
self.assert_(err == "", "Saw parse runtime err:" + str(err))
self.assert_(
num_bytes_used == exp_bytes_used,
"Expected %d bytes consumed, Saw %d." % (exp_bytes_used, num_bytes_used),
)
self.check_field(p4, "L2_hdr[0].DA", 0x102030405)
self.check_field(p4, "L2_hdr[0].SA", 0x60708090A0B)
self.check_field(p4, "L2_hdr[1].DA", 0x0C0D0E0F1011)
self.check_field(p4, "L2_hdr[1].SA", 0x121314151617)
self.check_field(p4, "L2_hdr[2].DA", 0x18191A1B1C1D)
self.check_field(p4, "L2_hdr[2].SA", 0x1E1F20212223)
self.check_field(p4, "L2_hdr[3].DA", 0x242526272829)
self.check_field(p4, "L2_hdr[3].SA", 0x2A2B2C2D2E2F)
self.check_field(p4, "L2_hdr[4].DA", 0x303132333435)
self.check_field(p4, "L2_hdr[4].SA", 0x363738393A3B)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
def test5c(self, debug=1):
program = """
layout L2_def { fields { DA : 48; SA : 48; } }
L2_def L2_hdr[1];
parser start { extract ( L2_hdr[0] ) ;
return P4_ERR ;
}
"""
pkt = [i for i in range(20)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
except GP4.GP4_Exceptions.SyntaxError as ex_err:
print "test5c: SyntaxError was expected:", ex_err.args
def test101(self, debug=1):
program = """
control my_ctrl_fun { apply_table( fred); }
control my_ctrl_fun { apply_table( fred); }
"""
exp_bytes_used = 5
pkt = [ 5+i for i in range(8) ]
try:
(p4, err, num_bytes_used ) = parse_and_run_test(program, pkt, init_state='start',
debug=debug)
self.assert_( False, 'Expected to see Syntax Error about Control func name already defined.' )
except GP4.GP4_Exceptions.SyntaxError as err:
print "Expected Syntax Error",err.data
self.assert_(True)
def test8b(self, debug=1):
program = """
layout L2_def { fields { type0: 8; } }
layout bad_def { fields { jjj: 8; } }
layout Type_1 { fields { four: 32; } }
L2_def L2_hdr;
bad_def bad_hdr;
Type_1 Type_1_hdr;
parser start {
extract ( L2_hdr ) ; /* 5 */
return switch ( L2_hdr.type0 )
{ 4 mask 6 : SECOND ;
default : BAD ;
}
}
parser BAD { extract ( bad_hdr ) ;
return BAD ;
}
parser SECOND { extract ( Type_1_hdr ) ;
return P4_PARSING_DONE ;
}
"""
exp_bytes_used = 5
pkt = [5 + i for i in range(8)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
self.assert_(err == "", "Saw parse runtime err:" + str(err))
self.assert_(
num_bytes_used == exp_bytes_used,
"Expected %d bytes consumed, Saw %d." % (exp_bytes_used, num_bytes_used),
)
self.check_field(p4, "L2_hdr.type0", 0x5)
self.check_field(p4, "Type_1_hdr.four", 0x6070809)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
def test9(self, debug=1):
program = """
layout L2_def { fields { len: 8;
other: 16;
data: *;
}
length (len * 2)>>1 + 1 - 1 ;
max_length 10;
}
L2_def L2_hdr;
parser start {
extract ( L2_hdr ) ;
return P4_PARSING_DONE ;
}
"""
exp_bytes_used = 10
pkt = [10 + i for i in range(10)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
self.assert_(err == "", "Saw parse runtime err:" + str(err))
self.assert_(
num_bytes_used == exp_bytes_used,
"Expected %d bytes consumed, Saw %d." % (exp_bytes_used, num_bytes_used),
)
self.check_field(p4, "L2_hdr.len", 10)
self.check_field(p4, "L2_hdr.other", 0xB0C)
self.check_field(p4, "L2_hdr.data", 0xD0E0F10111213)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
except GP4.GP4_Exceptions.SyntaxError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
except GP4.GP4_Exceptions.RuntimeParseError as err:
print "Unexpected Runtime Parse Error:", err.data
self.assert_(False)
def test5a(self, debug=1):
program = """
layout L2_def {
fields { DA : 48; SA : 48; }
}
L2_def L2_hdr[2];
parser start { extract ( L2_hdr[2] ) ; /* out of range */
return P4_PARSING_DONE ;
}
"""
pkt = [i for i in range(20)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Runtime Error was expected."
print err.data
def test7(self, debug=1):
program = """
layout L2_def {
fields { DA : 48; SA : 48; }
}
layout meta_def {
fields { number: 32 ; unused : 64;}
}
L2_def L2_hdr;
meta_def metadata meta_hdr;
parser start { extract ( L2_hdr ) ;
return GET_META ;
}
parser GET_META { set_metadata ( meta_hdr.number, 1234 ) ;
return P4_PARSING_DONE ;
}
"""
exp_bytes_used = 1 * 12
pkt = [i for i in range(12)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
self.assert_(err == "", "Saw parse runtime err:" + str(err))
self.assert_(
num_bytes_used == exp_bytes_used,
"Expected %d bytes consumed, Saw %d." % (exp_bytes_used, num_bytes_used),
)
self.check_field(p4, "L2_hdr.DA", 0x102030405)
self.check_field(p4, "L2_hdr.SA", 0x60708090A0B)
self.check_field(p4, "meta_hdr.number", 1234)
self.check_field(p4, "meta_hdr.unused", None)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
def test9a(self, debug=1):
program = """
layout L2_def { fields { len: 8;
other: 16;
data: *;
}
length (len * 2)>>1 + 1 - 1 ;
max_length 1;
}
L2_def L2_hdr;
parser start {
extract ( L2_hdr ) ;
return P4_PARSING_DONE ;
}
"""
exp_bytes_used = 10
pkt = [10 + i for i in range(10)]
try:
(p4, err, num_bytes_used) = parse_and_run_test(program, pkt, init_state="start", debug=debug)
self.assert_(False) # should have exception raised
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
except GP4.GP4_Exceptions.SyntaxError as err:
print "Unexpected Runtime Error:", err.data
self.assert_(False)
except GP4.GP4_Exceptions.RuntimeParseError as err:
print "Good: Expected Runtime Parse Error:", err.data
self.assert_(True)
self.assert_(False)
########################################################################################
if __name__ == '__main__':
# unittest.main()
# can run all tests in dir via:
# python -m unittest discover
if (True):
single = unittest.TestSuite()
single.addTest( test_dev('test209' ))
unittest.TextTestRunner().run(single)
else:
program = """
layout L2_def { fields { DA : 48; SA : 48; } }
L2_def L2_hdr[1];
parser start { extract ( L2_hdr[0] ) ;
return P4_ERR ;
}
"""
pkt = [ i for i in range(20) ]
try:
(p4, err, num_bytes_used ) = parse_and_run_test(program, pkt, init_state='start', debug=0)
except GP4.GP4_Exceptions.SyntaxError as ex_err:
print "test5c: SyntaxError was expected:", ex_err.args
print "len args is",len(ex_err.args)
def test102(self, debug=1):
program = """
layout L2_def { fields { DA : 48; SA : 48; EthType : 16; } }
layout L3_def { fields { stuff : 32; } }
L2_def L2_hdr;
L3_def L3_hdr[3];
parser start { extract ( L2_hdr ) ;
extract ( L3_hdr[next] );
extract ( L3_hdr[next] );
return P4_PARSING_DONE ; }
control ingress {
/* if ( valid ( L2_hdr) and ( L2_hdr.DA == 1234 ) ) { apply_table(a_table); } */
if ( L2_hdr.DA == 0x102030405 ) { apply_table(a_table); }
else {
do_another_ctrl_func ( ) ;
}
if ( L2_hdr.DA == 0xff ) { apply_table(a_table); }
else {
if ( valid ( L3_hdr[2] ) ) {apply_table(BAD_table); }
else {
if ( L3_hdr[1].stuff == 0x12131415 ) {
do_another_ctrl_func ( ) ;
}
}
}
}
control do_another_ctrl_func { apply_table(b_table); }
table a_table { actions { add_to_field ; } }
table b_table { actions { add_to_field ; } }
table BAD_table { actions { add_to_field ; } }
"""
exp_bytes_used = 22
pkt = [ i for i in range(22)]
try:
(p4, err, num_bytes_used ) = parse_and_run_test(program, pkt, init_state='start',
init_ctrl='ingress', debug=debug)
self.assert_( err=='', 'Saw parse runtime err:' + str(err) )
self.assert_( num_bytes_used == exp_bytes_used,
'Expected %d bytes consumed, Saw %d.' % (exp_bytes_used, num_bytes_used ))
self.check_field( p4, 'L2_hdr.DA', 0x102030405 )
self.check_field( p4, 'L2_hdr.SA', 0x60708090a0b )
self.check_field( p4, 'L2_hdr.EthType', 0xc0d )
self.check_field( p4, 'L3_hdr[0].stuff', 0xe0f1011)
self.check_field( p4, 'L3_hdr[1].stuff', 0x12131415)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:",err.data
self.assert_(False)
except GP4.GP4_Exceptions.InternalError as err:
print "Unexpected Internal Error:",err.data
self.assert_(False)
def test103(self, debug=1):
program = """
layout L2_def { fields { DA : 48; SA : 48; EthType : 16; } }
layout L3_def { fields { byte1 : 8; byte2 : 8; } }
L2_def L2_hdr;
L3_def L3_hdr[3];
parser start { extract ( L2_hdr ) ;
extract ( L3_hdr[next] );
extract ( L3_hdr[next] );
return P4_PARSING_DONE ; }
control ingress {
if ( L3_hdr[0].byte1 < L3_hdr[0].byte2 )
{
if ( L3_hdr[1].byte1 > L3_hdr[0].byte2 )
{
if ( ( L3_hdr[1].byte1 & L3_hdr[0].byte2) == 0 )
{
if ( ( L3_hdr[1].byte2 ^ L3_hdr[0].byte2) == 0x1e )
{
if ( ( L3_hdr[1].byte2 == 0x11 ) and not ( L3_hdr[0].byte2 == 0) )
{
apply_table (GOOD_table);
}
}
}
}
}
else { apply_table (BAD_table); }
}
table GOOD_table { actions { no_action ; } }
table BAD_table { actions { no_action ; } }
"""
exp_bytes_used = 18
pkt = [ i for i in range(exp_bytes_used)]
try:
(p4, err, num_bytes_used ) = parse_and_run_test(program, pkt, init_state='start',
init_ctrl='ingress', debug=debug)
self.assert_( err=='', 'Saw parse runtime err:' + str(err) )
self.assert_( num_bytes_used == exp_bytes_used,
'Expected %d bytes consumed, Saw %d.' % (exp_bytes_used, num_bytes_used ))
self.check_field( p4, 'L2_hdr.DA', 0x102030405 )
self.check_field( p4, 'L2_hdr.SA', 0x60708090a0b )
self.check_field( p4, 'L2_hdr.EthType', 0xc0d )
self.check_field( p4, 'L3_hdr[0].byte1', 0xe)
self.check_field( p4, 'L3_hdr[0].byte2', 0xf)
self.check_field( p4, 'L3_hdr[1].byte1', 0x10)
self.check_field( p4, 'L3_hdr[1].byte2', 0x11)
except GP4.GP4_Exceptions.RuntimeError as err:
print "Unexpected Runtime Error:",err.data
self.assert_(False)
except GP4.GP4_Exceptions.InternalError as err:
print "Unexpected Internal Error:",err.data
self.assert_(False)
