CSY/reowolf Changeset - 52ae67e7183e · Centrum Wiskunde & Informatica (CWI)

Changeset - 52ae67e7183e

Parent rev.

Child rev.

[Not reviewed]

0 4 0

MH - 4 years ago 2021-12-03 15:40:08
contact@maxhenger.nl

Remove stale code in testing suite

4 files changed with 34 insertions and 18 deletions:

src/protocol/ast.rs

src/protocol/tests/utils.rs

src/runtime/tests/data_transmission.rs

src/runtime/tests/mod.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -78,97 +78,97 @@ macro_rules! define_new_ast_id { @@
+                }
+            }
+        }
         impl IndexMut<$name> for Heap {
             fn index_mut(&mut self, index: $name) -> &mut Self::Output {
                 if let $wrapper_type(v) = &mut self.$indexed_arena[index.0] {
+                    v
                 } else {
                     unreachable!()
+                }
+            }
+        }
     };
     // Variant where we define the type, the Index and IndexMut traits, and an allocation function
+    (
         $name:ident, $parent:ty,
         index($indexed_type:ty, $wrapper_type:path, $indexed_arena:ident),
         alloc($fn_name:ident)
     ) => {
         define_new_ast_id!($name, $parent, index($indexed_type, $wrapper_type, $indexed_arena));
         impl Heap {
             pub fn $fn_name(&mut self, f: impl FnOnce($name) -> $indexed_type) -> $name {
                 $name(
                     self.$indexed_arena.alloc_with_id(|id| {
                         $wrapper_type(f($name(id)))
                     })
+                )
+            }
+        }
+    }
+}
 define_aliased_ast_id!(RootId, Id<Root>, index(Root, protocol_descriptions), alloc(alloc_protocol_description));
 define_aliased_ast_id!(PragmaId, Id<Pragma>, index(Pragma, pragmas), alloc(alloc_pragma));
 define_aliased_ast_id!(ImportId, Id<Import>, index(Import, imports), alloc(alloc_import));
 define_aliased_ast_id!(VariableId, Id<Variable>, index(Variable, variables), alloc(alloc_variable));
 define_aliased_ast_id!(DefinitionId, Id<Definition>, index(Definition, definitions));
 define_new_ast_id!(StructDefinitionId, DefinitionId, index(StructDefinition, Definition::Struct, definitions), alloc(alloc_struct_definition));
 define_new_ast_id!(EnumDefinitionId, DefinitionId, index(EnumDefinition, Definition::Enum, definitions), alloc(alloc_enum_definition));
 define_new_ast_id!(UnionDefinitionId, DefinitionId, index(UnionDefinition, Definition::Union, definitions), alloc(alloc_union_definition));
 define_new_ast_id!(ComponentDefinitionId, DefinitionId, index(ComponentDefinition, Definition::Component, definitions), alloc(alloc_component_definition));
 define_new_ast_id!(FunctionDefinitionId, DefinitionId, index(FunctionDefinition, Definition::Function, definitions), alloc(alloc_function_definition));
 define_aliased_ast_id!(StatementId, Id<Statement>, index(Statement, statements));
 define_new_ast_id!(BlockStatementId, StatementId, index(BlockStatement, Statement::Block, statements), alloc(alloc_block_statement));
 define_new_ast_id!(EndBlockStatementId, StatementId, index(EndBlockStatement, Statement::EndBlock, statements), alloc(alloc_end_block_statement));
-define_new_ast_id!(LocalStatementId, StatementId, index(LocalStatement, Statement::Local, statements), alloc(alloc_local_statement));
 define_new_ast_id!(LocalStatementId, StatementId, index(LocalStatement, Statement::Local, statements));
 define_new_ast_id!(MemoryStatementId, LocalStatementId);
 define_new_ast_id!(ChannelStatementId, LocalStatementId);
 define_new_ast_id!(LabeledStatementId, StatementId, index(LabeledStatement, Statement::Labeled, statements), alloc(alloc_labeled_statement));
 define_new_ast_id!(IfStatementId, StatementId, index(IfStatement, Statement::If, statements), alloc(alloc_if_statement));
 define_new_ast_id!(EndIfStatementId, StatementId, index(EndIfStatement, Statement::EndIf, statements), alloc(alloc_end_if_statement));
 define_new_ast_id!(WhileStatementId, StatementId, index(WhileStatement, Statement::While, statements), alloc(alloc_while_statement));
 define_new_ast_id!(EndWhileStatementId, StatementId, index(EndWhileStatement, Statement::EndWhile, statements), alloc(alloc_end_while_statement));
 define_new_ast_id!(BreakStatementId, StatementId, index(BreakStatement, Statement::Break, statements), alloc(alloc_break_statement));
 define_new_ast_id!(ContinueStatementId, StatementId, index(ContinueStatement, Statement::Continue, statements), alloc(alloc_continue_statement));
 define_new_ast_id!(SynchronousStatementId, StatementId, index(SynchronousStatement, Statement::Synchronous, statements), alloc(alloc_synchronous_statement));
 define_new_ast_id!(EndSynchronousStatementId, StatementId, index(EndSynchronousStatement, Statement::EndSynchronous, statements), alloc(alloc_end_synchronous_statement));
 define_new_ast_id!(ForkStatementId, StatementId, index(ForkStatement, Statement::Fork, statements), alloc(alloc_fork_statement));
 define_new_ast_id!(EndForkStatementId, StatementId, index(EndForkStatement, Statement::EndFork, statements), alloc(alloc_end_fork_statement));
 define_new_ast_id!(ReturnStatementId, StatementId, index(ReturnStatement, Statement::Return, statements), alloc(alloc_return_statement));
 define_new_ast_id!(GotoStatementId, StatementId, index(GotoStatement, Statement::Goto, statements), alloc(alloc_goto_statement));
 define_new_ast_id!(NewStatementId, StatementId, index(NewStatement, Statement::New, statements), alloc(alloc_new_statement));
 define_new_ast_id!(ExpressionStatementId, StatementId, index(ExpressionStatement, Statement::Expression, statements), alloc(alloc_expression_statement));
 define_aliased_ast_id!(ExpressionId, Id<Expression>, index(Expression, expressions));
 define_new_ast_id!(AssignmentExpressionId, ExpressionId, index(AssignmentExpression, Expression::Assignment, expressions), alloc(alloc_assignment_expression));
 define_new_ast_id!(BindingExpressionId, ExpressionId, index(BindingExpression, Expression::Binding, expressions), alloc(alloc_binding_expression));
 define_new_ast_id!(ConditionalExpressionId, ExpressionId, index(ConditionalExpression, Expression::Conditional, expressions), alloc(alloc_conditional_expression));
 define_new_ast_id!(BinaryExpressionId, ExpressionId, index(BinaryExpression, Expression::Binary, expressions), alloc(alloc_binary_expression));
 define_new_ast_id!(UnaryExpressionId, ExpressionId, index(UnaryExpression, Expression::Unary, expressions), alloc(alloc_unary_expression));
 define_new_ast_id!(IndexingExpressionId, ExpressionId, index(IndexingExpression, Expression::Indexing, expressions), alloc(alloc_indexing_expression));
 define_new_ast_id!(SlicingExpressionId, ExpressionId, index(SlicingExpression, Expression::Slicing, expressions), alloc(alloc_slicing_expression));
 define_new_ast_id!(SelectExpressionId, ExpressionId, index(SelectExpression, Expression::Select, expressions), alloc(alloc_select_expression));
 define_new_ast_id!(LiteralExpressionId, ExpressionId, index(LiteralExpression, Expression::Literal, expressions), alloc(alloc_literal_expression));
 define_new_ast_id!(CastExpressionId, ExpressionId, index(CastExpression, Expression::Cast, expressions), alloc(alloc_cast_expression));
 define_new_ast_id!(CallExpressionId, ExpressionId, index(CallExpression, Expression::Call, expressions), alloc(alloc_call_expression));
 define_new_ast_id!(VariableExpressionId, ExpressionId, index(VariableExpression, Expression::Variable, expressions), alloc(alloc_variable_expression));
 #[derive(Debug)]
 pub struct Heap {
     // Root arena, contains the entry point for different modules. Each root
     // contains lists of IDs that correspond to the other arenas.
     pub(crate) protocol_descriptions: Arena<Root>,
     // Contents of a file, these are the elements the `Root` elements refer to
     pragmas: Arena<Pragma>,
     pub(crate) imports: Arena<Import>,
     pub(crate) variables: Arena<Variable>,
     pub(crate) definitions: Arena<Definition>,
     pub(crate) statements: Arena<Statement>,
     pub(crate) expressions: Arena<Expression>,
+}
 impl Heap {
     pub fn new() -> Heap {

src/protocol/tests/utils.rs

➞

Show inline comments

 use crate::collections::StringPool;
 use crate::protocol::{
     Module,
     ast::*,
     input_source::*,
     parser::{
         Parser,
         type_table::*,
         symbol_table::SymbolTable,
         token_parsing::*,
     },
     eval::*,
 };
 use crate::protocol::{Module, ast::*, input_source::*, parser::{
     Parser,
     type_table::*,
     symbol_table::SymbolTable,
     token_parsing::*,
 }, eval::*, RunContext};
 // Carries information about the test into utility structures for builder-like
 // assertions
 #[derive(Clone, Copy)]
 struct TestCtx<'a> {
     test_name: &'a str,
     heap: &'a Heap,
     modules: &'a Vec<Module>,
     types: &'a TypeTable,
     symbols: &'a SymbolTable,
+}
 //------------------------------------------------------------------------------
 // Interface for parsing and compiling
 //------------------------------------------------------------------------------
 pub(crate) struct Tester {
     test_name: String,
     sources: Vec<String>
+}
 impl Tester {
     /// Constructs a new tester, allows adding multiple sources before compiling
     pub(crate) fn new<S: ToString>(test_name: S) -> Self {
         Self{
             test_name: test_name.to_string(),
             sources: Vec::new()
+        }
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to succeed.
     pub(crate) fn new_single_source_expect_ok<T: ToString, S: ToString>(test_name: T, source: S) -> AstOkTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_ok()
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to fail.
     pub(crate) fn new_single_source_expect_err<T: ToString, S: ToString>(test_name: T, source: S) -> AstErrTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_err()
+    }
@@ @@ -646,97 +640,97 @@ impl<'a> FunctionTester<'a> { @@
                     false,
                     "[{}] Expected call to succeed, but got {:?} for {}",
                     self.ctx.test_name, err, self.assert_postfix()
+                )
+            }
+        }
         if let Some(expected_result) = expected_result {
             debug_assert!(expected_result.get_heap_pos().is_none(), "comparing against heap thingamajigs is not yet implemented");
             assert!(
                 value::apply_equality_operator(&prompt.store, &prompt.store.stack[0], &expected_result),
                 "[{}] Result from call was {:?}, but expected {:?} for {}",
                 self.ctx.test_name, &prompt.store.stack[0], &expected_result, self.assert_postfix()
+            )
+        }
         self
+    }
     // Keeping this simple for now, will likely change
     pub(crate) fn call_err(self, expected_result: &str) -> Self {
         let (_, result) = self.eval_until_end();
         match result {
             Ok(_) => {
                 assert!(
                     false,
                     "[{}] Expected an error, but evaluation finished successfully for {}",
                     self.ctx.test_name, self.assert_postfix()
                 );
             },
             Err(err) => {
                 println!("DEBUG: Formatted evaluation error:\n{}", err);
                 debug_assert_eq!(err.statements.len(), 1);
                 assert!(
                     err.statements[0].message.contains(&expected_result),
                     "[{}] Expected error message to contain '{}', but it was '{}' for {}",
                     self.ctx.test_name, expected_result, err.statements[0].message, self.assert_postfix()
                 );
+            }
+        }
         self
+    }
     fn eval_until_end(&self) -> (Prompt, Result<EvalContinuation, EvalError>) {
         use crate::protocol::*;
         let mut prompt = Prompt::new(&self.ctx.types, &self.ctx.heap, self.def.this.upcast(), 0, ValueGroup::new_stack(Vec::new()));
-        let mut call_context = EvalContext::None;
+        let mut call_context = FakeRunContext{};
         loop {
             let result = prompt.step(&self.ctx.types, &self.ctx.heap, &self.ctx.modules, &mut call_context);
             match result {
                 Ok(EvalContinuation::Stepping) => {},
                 _ => return (prompt, result),
+            }
+        }
+    }
     fn assert_postfix(&self) -> String {
         format!("Function{{ name: {} }}", self.def.identifier.value.as_str())
+    }
+}
 pub(crate) struct VariableTester<'a> {
     ctx: TestCtx<'a>,
     definition_id: DefinitionId,
     variable: &'a Variable,
     var_expr: &'a VariableExpression,
+}
 impl<'a> VariableTester<'a> {
     fn new(
         ctx: TestCtx<'a>, definition_id: DefinitionId, variable: &'a Variable, var_expr: &'a VariableExpression
     ) -> Self {
         Self{ ctx, definition_id, variable, var_expr }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_parser_type(&mut serialized, self.ctx.heap, &self.variable.parser_type);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected parser type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         // Lookup concrete type in type table
         let mono_data = self.ctx.types.get_procedure_expression_data(&self.definition_id, 0);
         let concrete_type = &mono_data.expr_data[self.var_expr.unique_id_in_definition as usize].expr_type;
         // Serialize and check
         let mut serialized = String::new();
         serialize_concrete_type(&mut serialized, self.ctx.heap, self.definition_id, concrete_type);
     let stmt = &heap[start];
     match stmt {
         Statement::Block(stmt) => {
             for stmt_id in &stmt.statements {
                 if let Some(id) = seek_expr_in_stmt(heap, *stmt_id, f) {
                     return Some(id)
+                }
+            }
             None
         },
         Statement::Labeled(stmt) => {
             seek_expr_in_stmt(heap, stmt.body, f)
         },
         Statement::If(stmt) => {
             None
             .or_else(|| seek_expr_in_expr(heap, stmt.test, f))
             .or_else(|| seek_expr_in_stmt(heap, stmt.true_body.upcast(), f))
             .or_else(|| if let Some(false_body) = stmt.false_body {
                 seek_expr_in_stmt(heap, false_body.upcast(), f)
             } else {
                 None
             })
         },
         Statement::While(stmt) => {
             None
             .or_else(|| seek_expr_in_expr(heap, stmt.test, f))
             .or_else(|| seek_expr_in_stmt(heap, stmt.body.upcast(), f))
         },
         Statement::Synchronous(stmt) => {
             seek_expr_in_stmt(heap, stmt.body.upcast(), f)
         },
         Statement::Return(stmt) => {
             for expr_id in &stmt.expressions {
                 if let Some(id) = seek_expr_in_expr(heap, *expr_id, f) {
                     return Some(id);
+                }
+            }
             None
         },
         Statement::New(stmt) => {
             seek_expr_in_expr(heap, stmt.expression.upcast(), f)
         },
         Statement::Expression(stmt) => {
             seek_expr_in_expr(heap, stmt.expression, f)
         },
         _ => None
+    }
+}
 struct FakeRunContext{}
 impl RunContext for FakeRunContext {
     fn performed_put(&mut self, _port: PortId) -> bool {
         unreachable!("'put' called in compiler testing code")
+    }
     fn performed_get(&mut self, _port: PortId) -> Option<ValueGroup> {
         unreachable!("'get' called in compiler testing code")
+    }
     fn fires(&mut self, _port: PortId) -> Option<Value> {
         unreachable!("'fires' called in compiler testing code")
+    }
     fn performed_fork(&mut self) -> Option<bool> {
         unreachable!("'fork' called in compiler testing code")
+    }
     fn created_channel(&mut self) -> Option<(Value, Value)> {
         unreachable!("channel created in compiler testing code")
+    }
+}
@@ \ No newline at end of file @@

src/runtime/tests/data_transmission.rs

➞

Show inline comments

@@ @@ -10,102 +10,102 @@ fn test_doing_nothing() { @@
     // exits), then the test works
     const CODE: &'static str ="
     primitive silent_willy(u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync { index += 1; }
+        }
+    }
     ";
     let thing = TestTimer::new("doing_nothing");
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "silent_willy", ValueGroup::new_stack(vec![
             Value::UInt32(NUM_LOOPS),
         ])).expect("create component");
     });
+}
 #[test]
 fn test_single_put_and_get() {
     const CODE: &'static str = "
     primitive putter(out<bool> sender, u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync {
                 put(sender, true);
+            }
             index += 1;
+        }
+    }
     primitive getter(in<bool> receiver, u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync {
                 auto result = get(receiver);
                 assert(result);
+            }
             index += 1;
+        }
+    }
     ";
     let thing = TestTimer::new("single_put_and_get");
     run_test_in_runtime(CODE, |api| {
         let channel = api.create_channel().unwrap();
         api.create_connector("", "putter", ValueGroup::new_stack(vec![
-            Value::Output(PortId(Id{ connector_id: 0, u32_suffix: channel.putter_id.index })),
+            Value::Output(PortId::new(channel.putter_id.index)),
             Value::UInt32(NUM_LOOPS)
         ])).expect("create putter");
         api.create_connector("", "getter", ValueGroup::new_stack(vec![
-            Value::Input(PortId(Id{ connector_id: 0, u32_suffix: channel.getter_id.index })),
+            Value::Input(PortId::new(channel.getter_id.index)),
             Value::UInt32(NUM_LOOPS)
         ])).expect("create getter");
     });
+}
 #[test]
 fn test_combined_put_and_get() {
     const CODE: &'static str = "
     primitive put_then_get(out<bool> output, in<bool> input, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync {
                 put(output, true);
                 auto value = get(input);
                 assert(value);
                 index += 1;
+            }
+        }
+    }
     composite constructor(u32 num_loops) {
         channel output_a -> input_a;
         channel output_b -> input_b;
         new put_then_get(output_a, input_b, num_loops);
         new put_then_get(output_b, input_a, num_loops);
+    }
     ";
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "constructor", ValueGroup::new_stack(vec![
             Value::UInt32(NUM_LOOPS),
         ])).expect("create connector");
     })
+}
 #[test]
 fn test_multi_put_and_get() {
     const CODE: &'static str = "
     primitive putter_static(out<u8> vals, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync {
                 put(vals, 0b00000001);
                 put(vals, 0b00000100);
                 put(vals, 0b00010000);
                 put(vals, 0b01000000);
+            }
             index += 1;

src/runtime/tests/mod.rs

➞

Show inline comments

 mod network_shapes;
 mod api_component;
 mod speculation;
 mod data_transmission;
 mod sync_failure;
 use super::*;
 use crate::{PortId, ProtocolDescription};
 use crate::common::Id;
 use crate::ProtocolDescription;
 use crate::protocol::eval::*;
 use crate::runtime::native::{ApplicationSyncAction};
 // Generic testing constants, use when appropriate to simplify stress-testing
 // pub(crate) const NUM_THREADS: u32 =  8;     // number of threads in runtime
 // pub(crate) const NUM_INSTANCES: u32 = 750;  // number of test instances constructed
 // pub(crate) const NUM_LOOPS: u32 = 10;       // number of loops within a single test (not used by all tests)
 pub(crate) const NUM_THREADS: u32 = 6;
 pub(crate) const NUM_INSTANCES: u32 = 2;
 pub(crate) const NUM_LOOPS: u32 = 1;
 fn create_runtime(pdl: &str) -> Runtime {
     let protocol = ProtocolDescription::parse(pdl.as_bytes()).expect("parse pdl");
     let runtime = Runtime::new(NUM_THREADS, protocol);
     return runtime;
+}
 fn run_test_in_runtime<F: Fn(&mut ApplicationInterface)>(pdl: &str, constructor: F) {
     let protocol = ProtocolDescription::parse(pdl.as_bytes())
         .expect("parse PDL");
     let runtime = Runtime::new(NUM_THREADS, protocol);
     let mut api = runtime.create_interface();
     for _ in 0..NUM_INSTANCES {
         constructor(&mut api);
+    }
+}
 pub(crate) struct TestTimer {
     name: &'static str,
     started: std::time::Instant
+}
 impl TestTimer {
     pub(crate) fn new(name: &'static str) -> Self {
         Self{ name, started: std::time::Instant::now() }
+    }
+}
 impl Drop for TestTimer {
     fn drop(&mut self) {
         let delta = std::time::Instant::now() - self.started;
         let nanos = (delta.as_secs_f64() * 1_000_000.0) as u64;
         let millis = nanos / 1000;
         let nanos = nanos % 1000;

0 comments (0 inline, 0 general)