792 lines
22 KiB
Rust
792 lines
22 KiB
Rust
#![cfg(test)]
|
|
|
|
use crate::*;
|
|
|
|
macro_rules! test {
|
|
( $x:expr, $y:expr, $z:pat ) => {
|
|
let ret = all_consuming($x)(Span::new_extra($y, Extra::default()));
|
|
if let $z = ret {
|
|
} else {
|
|
assert!(false, "{:?}", ret)
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_pulldown_strength() {
|
|
test!(pulldown_strength, "(supply0, strong1)", Ok((_, _)));
|
|
test!(pulldown_strength, "(pull1, weak0)", Ok((_, _)));
|
|
test!(pulldown_strength, "(pull0)", Ok((_, _)));
|
|
test!(pulldown_strength, "(pull0)", Ok((_, _)));
|
|
test!(pulldown_strength, "(pull0)", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_pullup_strength() {
|
|
test!(pullup_strength, "(supply0, strong1)", Ok((_, _)));
|
|
test!(pullup_strength, "(pull1, weak0)", Ok((_, _)));
|
|
test!(pullup_strength, "(supply1)", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_cmos_switchtype() {
|
|
test!(cmos_switchtype, "cmos ", Ok((_, _)));
|
|
test!(cmos_switchtype, "rcmos ", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_enable_gatetype() {
|
|
test!(enable_gatetype, "bufif0 ", Ok((_, _)));
|
|
test!(enable_gatetype, "bufif1 ", Ok((_, _)));
|
|
test!(enable_gatetype, "notif0 ", Ok((_, _)));
|
|
test!(enable_gatetype, "notif1 ", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_mos_switchtype() {
|
|
test!(mos_switchtype, "nmos ", Ok((_, _)));
|
|
test!(mos_switchtype, "pmos ", Ok((_, _)));
|
|
test!(mos_switchtype, "rnmos ", Ok((_, _)));
|
|
test!(mos_switchtype, "rpmos ", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_n_input_gatetype() {
|
|
test!(n_input_gatetype, "and ", Ok((_, _)));
|
|
test!(n_input_gatetype, "nand ", Ok((_, _)));
|
|
test!(n_input_gatetype, "or ", Ok((_, _)));
|
|
test!(n_input_gatetype, "nor ", Ok((_, _)));
|
|
test!(n_input_gatetype, "xor ", Ok((_, _)));
|
|
test!(n_input_gatetype, "xnor ", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_n_output_gatetype() {
|
|
test!(n_output_gatetype, "buf ", Ok((_, _)));
|
|
test!(n_output_gatetype, "not ", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_pass_en_switchtype() {
|
|
test!(pass_en_switchtype, "tranif0 ", Ok((_, _)));
|
|
test!(pass_en_switchtype, "tranif1 ", Ok((_, _)));
|
|
test!(pass_en_switchtype, "rtranif0 ", Ok((_, _)));
|
|
test!(pass_en_switchtype, "rtranif1 ", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_pass_switchtype() {
|
|
test!(pass_switchtype, "tran ", Ok((_, _)));
|
|
test!(pass_switchtype, "rtran ", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_library_text() {
|
|
test!(
|
|
library_text,
|
|
"library rtlLib \"*.v\" -incdir \"aaa\";\ninclude \"bbb\";;",
|
|
Ok((_, _))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_timeunits_declaration() {
|
|
test!(timeunits_declaration, "timeunit 1.0ps;", Ok((_, _)));
|
|
test!(timeunits_declaration, "timeunit 1.0ps / 20ms;", Ok((_, _)));
|
|
test!(timeunits_declaration, "timeprecision 10.0fs;", Ok((_, _)));
|
|
test!(
|
|
timeunits_declaration,
|
|
"timeunit 10.0fs; timeprecision 20s;",
|
|
Ok((_, _))
|
|
);
|
|
test!(
|
|
timeunits_declaration,
|
|
"timeprecision 10.0fs; timeunit 20s \n;",
|
|
Ok((_, _))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_data_type() {
|
|
test!(
|
|
data_type,
|
|
"struct { bit [7:0] opcode; bit [23:0] addr; }",
|
|
Ok((_, DataType::StructUnion(_)))
|
|
);
|
|
test!(
|
|
data_type,
|
|
"struct packed signed { int a; shortint b; byte c; bit [7:0] d; }",
|
|
Ok((_, DataType::StructUnion(_)))
|
|
);
|
|
test!(
|
|
data_type,
|
|
"union { int i; shortreal f; } ",
|
|
Ok((_, DataType::StructUnion(_)))
|
|
);
|
|
test!(
|
|
data_type,
|
|
"struct { bit isfloat; union { int i; shortreal f; } n; }",
|
|
Ok((_, DataType::StructUnion(_)))
|
|
);
|
|
test!(
|
|
data_type,
|
|
"union packed { s_atmcell acell; bit [423:0] bit_slice; bit [52:0][7:0] byte_slice; }",
|
|
Ok((_, DataType::StructUnion(_)))
|
|
);
|
|
test!(
|
|
data_type,
|
|
"union tagged { void Invalid; int Valid; }",
|
|
Ok((_, DataType::StructUnion(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_local_parameter_declaration() {
|
|
test!(
|
|
local_parameter_declaration,
|
|
"localparam byte colon1 = \":\" ",
|
|
Ok((_, LocalParameterDeclaration::Param(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parameter_declaration() {
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter logic flag = 1 ",
|
|
Ok((_, ParameterDeclaration::Param(_)))
|
|
);
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter e = 25, f = 9 ",
|
|
Ok((_, ParameterDeclaration::Param(_)))
|
|
);
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter byte_size = 8, byte_mask = byte_size - 1",
|
|
Ok((_, ParameterDeclaration::Param(_)))
|
|
);
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter signed [3:0] mux_selector = 0",
|
|
Ok((_, ParameterDeclaration::Param(_)))
|
|
);
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter real r1 = 3.5e17",
|
|
Ok((_, ParameterDeclaration::Param(_)))
|
|
);
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter logic [31:0] P1 [3:0] = '{ 1, 2, 3, 4 } ",
|
|
Ok((_, ParameterDeclaration::Param(_)))
|
|
);
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter r2 = $ ",
|
|
Ok((_, ParameterDeclaration::Param(_)))
|
|
);
|
|
test!(
|
|
parameter_declaration,
|
|
"parameter type p2 = shortint ",
|
|
Ok((_, ParameterDeclaration::Type(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_specparam_declaration() {
|
|
test!(specparam_declaration, "specparam delay = 10 ; ", Ok((_, _)));
|
|
test!(
|
|
specparam_declaration,
|
|
"specparam tRise_clk_q = 150, tFall_clk_q = 200;",
|
|
Ok((_, _))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_inout_declaration() {
|
|
test!(inout_declaration, "inout a", Ok((_, _)));
|
|
test!(inout_declaration, "inout [7:0] a", Ok((_, _)));
|
|
test!(inout_declaration, "inout signed [7:0] a", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_net_type_declaration() {
|
|
test!(
|
|
net_type_declaration,
|
|
"nettype T wT;",
|
|
Ok((_, NetTypeDeclaration::DataType(_)))
|
|
);
|
|
test!(
|
|
net_type_declaration,
|
|
"nettype T wTsum with Tsum;",
|
|
Ok((_, NetTypeDeclaration::DataType(_)))
|
|
);
|
|
test!(
|
|
net_type_declaration,
|
|
"nettype MyBaseT::T narrowTsum with MyBaseT::Tsum;",
|
|
Ok((_, NetTypeDeclaration::DataType(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_net_declaration() {
|
|
test!(
|
|
net_declaration,
|
|
"trireg (large) logic #(0,0,0) cap1;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"wire addressT w1;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"wire struct packed { logic ecc; logic [7:0] data; } memsig;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"wire w;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"wire [15:0] w;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"interconnect w1;",
|
|
Ok((_, NetDeclaration::Interconnect(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"interconnect [3:0] w2;",
|
|
Ok((_, NetDeclaration::Interconnect(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"interconnect [3:0] w3 [1:0];",
|
|
Ok((_, NetDeclaration::Interconnect(_)))
|
|
);
|
|
test!(net_declaration, "interconnect logic [3:0] w4;", Err(_));
|
|
test!(net_declaration, "interconnect #(1,2,3) w5;", Err(_));
|
|
test!(
|
|
net_declaration,
|
|
"wand w;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"tri [15:0] busa;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"trireg (small) storeit;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"wire w1, w2;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"tri1 scalared [63:0] bus64;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
test!(
|
|
net_declaration,
|
|
"tri vectored [31:0] data;",
|
|
Ok((_, NetDeclaration::NetType(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_data_declaration() {
|
|
test!(
|
|
data_declaration,
|
|
"shortint s1, s2[0:9];",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"var byte my_byte;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"var v;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"var [15:0] vw;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"var enum bit { clear, error } status;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"var reg r;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"int i = 0;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"logic a;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"logic[3:0] v;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"logic signed [3:0] signed_reg;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"logic [-1:4] b;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"logic [4:0] x, y, z;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"int unsigned ui;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"int signed si;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"string myName = default_name;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"byte c = \"A\";",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"bit [10:0] b = \"x41\";",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"bit [1:4][7:0] h = \"hello\" ;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"event done;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"event done_too = done;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"event empty = null;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef int intP;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"intP a, b;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef enum type_identifier;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef struct type_identifier;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef union type_identifier;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef class type_identifier;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef interface class type_identifier;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef type_identifier;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"typedef C::T c_t;",
|
|
Ok((_, DataDeclaration::TypeDeclaration(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"enum {red, yellow, green} light1, light2;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"enum bit [1:0] {IDLE, XX='x, S1=2'b01, S2=2'b10} state, next;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"enum integer {IDLE, XX='x, S1='b01, S2='b10} state, next;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"enum {bronze=3, silver, gold} medal;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"enum {a=3, b=7, c} alphabet;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"enum bit [3:0] {bronze='h3, silver, gold='h5} medal2;",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"integer i_array[*];",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"bit [20:0] array_b[string];",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"event ev_array[myClass];",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"int array_name [*];",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"int array_name1 [ integer ];",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"int a[int] = '{default:1};",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
test!(
|
|
data_declaration,
|
|
"byte q1[$];",
|
|
Ok((_, DataDeclaration::Variable(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_drive_strength() {
|
|
test!(drive_strength, "(supply0, strong1)", Ok((_, _)));
|
|
test!(drive_strength, "(pull1, weak0)", Ok((_, _)));
|
|
test!(drive_strength, "(pull0, highz1)", Ok((_, _)));
|
|
test!(drive_strength, "(weak1, highz0)", Ok((_, _)));
|
|
test!(drive_strength, "(highz0, supply1)", Ok((_, _)));
|
|
test!(drive_strength, "(highz1, strong0)", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_charge_strength() {
|
|
test!(charge_strength, "( small)", Ok((_, _)));
|
|
test!(charge_strength, "( medium )", Ok((_, _)));
|
|
test!(charge_strength, "(large)", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_blocking_assignment() {
|
|
test!(
|
|
blocking_assignment,
|
|
"idest = new [3] (isrc)",
|
|
Ok((_, BlockingAssignment::NonrangeVariable(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_primary() {
|
|
test!(primary, "2.1ns ", Ok((_, Primary::PrimaryLiteral(_))));
|
|
test!(primary, "40 ps ", Ok((_, Primary::PrimaryLiteral(_))));
|
|
test!(primary, "'0", Ok((_, Primary::PrimaryLiteral(_))));
|
|
test!(primary, "10", Ok((_, Primary::PrimaryLiteral(_))));
|
|
test!(primary, "\"aaa\"", Ok((_, Primary::PrimaryLiteral(_))));
|
|
test!(primary, "this ", Ok((_, Primary::This(_))));
|
|
test!(primary, "$", Ok((_, Primary::Dollar(_))));
|
|
test!(primary, "null ", Ok((_, Primary::Null(_))));
|
|
}
|
|
|
|
#[test]
|
|
fn test_cast() {
|
|
test!(cast, "int'(2.0 * 3.0)", Ok((_, _)));
|
|
test!(cast, "shortint'({8'hFA,8'hCE}) ", Ok((_, _)));
|
|
test!(cast, "signed'(x)", Ok((_, _)));
|
|
test!(cast, "const'(x)", Ok((_, _)));
|
|
test!(cast, "type_t'(x)", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_number() {
|
|
test!(number, "659", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "'h 837FF", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "'h 837FF", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "'o7460", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "'4af", Err(_));
|
|
test!(number, "4'b1001", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "5 'D 3", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "3'b01x", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "12'hx", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "16'hz", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "8 'd -6", Err(_));
|
|
test!(number, "4 'shf", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "16'sd?", Ok((_, Number::IntegralNumber(_))));
|
|
test!(number, "27_195_000", Ok((_, Number::IntegralNumber(_))));
|
|
test!(
|
|
number,
|
|
"16'b0011_0101_0001_1111",
|
|
Ok((_, Number::IntegralNumber(_)))
|
|
);
|
|
test!(
|
|
number,
|
|
"32 'h 12ab_f001",
|
|
Ok((_, Number::IntegralNumber(_)))
|
|
);
|
|
test!(number, "1.2", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "0.1", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "2394.26331", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "1.2E12", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "1.30e-2", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "0.1e-0", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "23E10", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "29E-2", Ok((_, Number::RealNumber(_))));
|
|
test!(number, "236.123_763_e-12", Ok((_, Number::RealNumber(_))));
|
|
test!(number, ".12", Err(_));
|
|
test!(number, "9.", Err(_));
|
|
test!(number, "4.E3", Err(_));
|
|
test!(number, ".2e-7", Err(_));
|
|
}
|
|
|
|
#[test]
|
|
fn test_unbased_unsized_literal() {
|
|
test!(unbased_unsized_literal, "'0", Ok((_, _)));
|
|
test!(unbased_unsized_literal, "'1", Ok((_, _)));
|
|
test!(unbased_unsized_literal, "'x", Ok((_, _)));
|
|
test!(unbased_unsized_literal, "'z", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_net_lvalue() {
|
|
test!(net_lvalue, "A", Ok((_, _)));
|
|
test!(net_lvalue, "{A[7:0],A[15:8],A[23:16]}", Ok((_, _)));
|
|
test!(net_lvalue, "'{A[7:0],A[15:8]}", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_variable_lvalue() {
|
|
test!(variable_lvalue, "A", Ok((_, _)));
|
|
test!(variable_lvalue, "{A[7:0],A[15:8],A[23:16]}", Ok((_, _)));
|
|
test!(variable_lvalue, "'{A[7:0],A[15:8]}", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_nonrange_variable_lvalue() {
|
|
test!(nonrange_variable_lvalue, "A", Ok((_, _)));
|
|
test!(nonrange_variable_lvalue, "A[1][2][3]", Ok((_, _)));
|
|
//TODO
|
|
//test!(nonrange_variable_lvalue, "A[][2][3]", Ok((_, _)));
|
|
//test!(nonrange_variable_lvalue, "A[][]", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_unary_operator() {
|
|
test!(unary_operator, "+", Ok((_, _)));
|
|
test!(unary_operator, "-", Ok((_, _)));
|
|
test!(unary_operator, "!", Ok((_, _)));
|
|
test!(unary_operator, "&", Ok((_, _)));
|
|
test!(unary_operator, "|", Ok((_, _)));
|
|
test!(unary_operator, "~&", Ok((_, _)));
|
|
test!(unary_operator, "~|", Ok((_, _)));
|
|
test!(unary_operator, "~^", Ok((_, _)));
|
|
test!(unary_operator, "^~", Ok((_, _)));
|
|
test!(unary_operator, "^", Ok((_, _)));
|
|
test!(unary_operator, "~", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_binary_operator() {
|
|
test!(binary_operator, "+", Ok((_, _)));
|
|
test!(binary_operator, "-", Ok((_, _)));
|
|
test!(binary_operator, "**", Ok((_, _)));
|
|
test!(binary_operator, "*", Ok((_, _)));
|
|
test!(binary_operator, "/", Ok((_, _)));
|
|
test!(binary_operator, "%", Ok((_, _)));
|
|
test!(binary_operator, "===", Ok((_, _)));
|
|
test!(binary_operator, "==?", Ok((_, _)));
|
|
test!(binary_operator, "==", Ok((_, _)));
|
|
test!(binary_operator, "!==", Ok((_, _)));
|
|
test!(binary_operator, "!=?", Ok((_, _)));
|
|
test!(binary_operator, "!=", Ok((_, _)));
|
|
test!(binary_operator, "&&", Ok((_, _)));
|
|
test!(binary_operator, "||", Ok((_, _)));
|
|
test!(binary_operator, "&", Ok((_, _)));
|
|
test!(binary_operator, "|", Ok((_, _)));
|
|
test!(binary_operator, "^~", Ok((_, _)));
|
|
test!(binary_operator, "^", Ok((_, _)));
|
|
test!(binary_operator, "~^", Ok((_, _)));
|
|
test!(binary_operator, ">>>", Ok((_, _)));
|
|
test!(binary_operator, ">>", Ok((_, _)));
|
|
test!(binary_operator, "<<<", Ok((_, _)));
|
|
test!(binary_operator, "<<", Ok((_, _)));
|
|
test!(binary_operator, "->", Ok((_, _)));
|
|
test!(binary_operator, "<->", Ok((_, _)));
|
|
test!(binary_operator, "<=", Ok((_, _)));
|
|
test!(binary_operator, "<", Ok((_, _)));
|
|
test!(binary_operator, ">=", Ok((_, _)));
|
|
test!(binary_operator, ">", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_inc_or_dec_operator() {
|
|
test!(inc_or_dec_operator, "++", Ok((_, _)));
|
|
test!(inc_or_dec_operator, "--", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_unary_module_path_operator() {
|
|
test!(unary_module_path_operator, "!", Ok((_, _)));
|
|
test!(unary_module_path_operator, "&", Ok((_, _)));
|
|
test!(unary_module_path_operator, "|", Ok((_, _)));
|
|
test!(unary_module_path_operator, "~&", Ok((_, _)));
|
|
test!(unary_module_path_operator, "~|", Ok((_, _)));
|
|
test!(unary_module_path_operator, "~^", Ok((_, _)));
|
|
test!(unary_module_path_operator, "^~", Ok((_, _)));
|
|
test!(unary_module_path_operator, "^", Ok((_, _)));
|
|
test!(unary_module_path_operator, "~", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_binary_module_path_operator() {
|
|
test!(binary_module_path_operator, "==", Ok((_, _)));
|
|
test!(binary_module_path_operator, "!=", Ok((_, _)));
|
|
test!(binary_module_path_operator, "&&", Ok((_, _)));
|
|
test!(binary_module_path_operator, "||", Ok((_, _)));
|
|
test!(binary_module_path_operator, "&", Ok((_, _)));
|
|
test!(binary_module_path_operator, "|", Ok((_, _)));
|
|
test!(binary_module_path_operator, "^~", Ok((_, _)));
|
|
test!(binary_module_path_operator, "^", Ok((_, _)));
|
|
test!(binary_module_path_operator, "~^", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_string_literal() {
|
|
test!(string_literal, "\"aaa aaaa\"", Ok((_, _)));
|
|
test!(string_literal, r#""aaa\" aaaa""#, Ok((_, _)));
|
|
test!(string_literal, r#""aaa\"""#, Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_identifier() {
|
|
test!(
|
|
identifier,
|
|
"shiftreg_a",
|
|
Ok((_, Identifier::SimpleIdentifier(_)))
|
|
);
|
|
test!(
|
|
identifier,
|
|
"_bus3",
|
|
Ok((_, Identifier::SimpleIdentifier(_)))
|
|
);
|
|
test!(
|
|
identifier,
|
|
"n$657",
|
|
Ok((_, Identifier::SimpleIdentifier(_)))
|
|
);
|
|
test!(
|
|
identifier,
|
|
"\\busa+index",
|
|
Ok((_, Identifier::EscapedIdentifier(_)))
|
|
);
|
|
test!(
|
|
identifier,
|
|
"\\-clock",
|
|
Ok((_, Identifier::EscapedIdentifier(_)))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_system_tf_identifier() {
|
|
test!(system_tf_identifier, "$display", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_comment() {
|
|
test!(comment, "// comment", Ok((_, _)));
|
|
test!(comment, "/* comment\n\n */", Ok((_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_attribute_instance() {
|
|
test!(
|
|
attribute_instance,
|
|
"(* full_case, parallel_case *)",
|
|
Ok((_, _))
|
|
);
|
|
test!(attribute_instance, "(* full_case=1 *)", Ok((_, _)));
|
|
test!(
|
|
attribute_instance,
|
|
"(* full_case=1, parallel_case = 0 *)",
|
|
Ok((_, _))
|
|
);
|
|
}
|