Value::OutputArray(_) => todo!(),

            Value::MessageArray(_) => todo!(),

            Value::BooleanArray(_) => todo!(),

            Value::ByteArray(_) => todo!(),

            Value::ShortArray(_) => todo!(),

            Value::IntArray(_) => todo!(),

            Value::LongArray(_) => todo!(),

            _ => unreachable!(),

        }

    }

    fn length(&self) -> Option<Value> {

        // The subject must be either a message or an array

        match self {

            Value::Message(MessageValue(None)) => {

                // It is inconsistent to get length from the null message

                None

            }

            Value::Message(MessageValue(Some(buffer))) => {

                Some(Value::Int(IntValue((buffer.len()).try_into().unwrap())))

            }

            Value::InputArray(InputArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            Value::OutputArray(OutputArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            Value::MessageArray(MessageArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            Value::BooleanArray(BooleanArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            Value::ByteArray(ByteArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            Value::ShortArray(ShortArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            Value::IntArray(IntArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            Value::LongArray(LongArrayValue(vec)) => {

                Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))

            }

            _ => unreachable!(),

        }

    }

    fn plus(&self, other: &Value) -> Value {

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            _ => unimplemented!(),

        }

    }

    fn minus(&self, other: &Value) -> Value {

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            _ => unimplemented!(),

        }

    }

    fn modulus(&self, other: &Value) -> Value {

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            _ => unimplemented!(),

        }

    }

    fn eq(&self, other: &Value) -> Value {

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            _ => unimplemented!(),

        }

    }

    fn neq(&self, other: &Value) -> Value {

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            }

            _ => unimplemented!(),

        }

    }

    fn lt(&self, other: &Value) -> Value {

        assert!(!self.exact_type().array);

        assert!(!other.exact_type().array);

        match (self.exact_type().primitive, other.exact_type().primitive) {

            (PrimitiveType::Byte, PrimitiveType::Byte) => {

                Value::Boolean(BooleanValue(i8::from(self) < i8::from(other)))

            }

            (PrimitiveType::Byte, PrimitiveType::Short) => {

                Value::Boolean(BooleanValue(i16::from(self) < i16::from(other)))

            }

            (PrimitiveType::Byte, PrimitiveType::Int) => {

                Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))

            }

            (PrimitiveType::Byte, PrimitiveType::Long) => {

                Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))

            }

            (PrimitiveType::Short, PrimitiveType::Byte) => {

                Value::Boolean(BooleanValue(i16::from(self) < i16::from(other)))

            }

            (PrimitiveType::Short, PrimitiveType::Short) => {

                Value::Boolean(BooleanValue(i16::from(self) < i16::from(other)))

            }

            (PrimitiveType::Short, PrimitiveType::Int) => {

                Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))

            }

            (PrimitiveType::Short, PrimitiveType::Long) => {

                Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))

            }

            (PrimitiveType::Int, PrimitiveType::Byte) => {

                Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))

            }

            (PrimitiveType::Int, PrimitiveType::Short) => {

                Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))

            }

            (PrimitiveType::Int, PrimitiveType::Int) => {

                Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))

            }

            (PrimitiveType::Int, PrimitiveType::Long) => {

                Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))

            }

            (PrimitiveType::Long, PrimitiveType::Byte) => {

                Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))

            }

            (PrimitiveType::Long, PrimitiveType::Short) => {

                Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))

            }

            (PrimitiveType::Long, PrimitiveType::Int) => {

                Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))

            }

            Expression::Select(selecting) => {

                // Reference to subject

                let subject;

                match &h[selecting.subject] {

                    Expression::Variable(var) => {

                        let var = var.declaration.unwrap();

                        subject = self.map.get(&var).unwrap();

                    }

                    _ => unreachable!(),

                }

                match subject.length() {

                    Some(value) => Ok(value),

                    None => Err(EvalContinuation::Inconsistent),

                }

            }

            _ => unimplemented!("{:?}", h[rexpr]),

        }

    }

    fn eval(&mut self, h: &Heap, ctx: &mut EvalContext, expr: ExpressionId) -> EvalResult {

        match &h[expr] {

            Expression::Assignment(expr) => {

                let value = self.eval(h, ctx, expr.right)?;

                match expr.operation {

                    AssignmentOperator::Set => {

                        self.update(h, ctx, expr.left, value.clone())?;

                    }

                    AssignmentOperator::Added => {

                        let old = self.get(h, ctx, expr.left)?;

                        self.update(h, ctx, expr.left, old.plus(&value))?;

                    }

                    AssignmentOperator::Subtracted => {

                        let old = self.get(h, ctx, expr.left)?;

                        self.update(h, ctx, expr.left, old.minus(&value))?;

                    }

                    _ => unimplemented!("{:?}", expr),

                }

                Ok(value)

            }

            Expression::Conditional(expr) => {

                let test = self.eval(h, ctx, expr.test)?;

                if test.as_boolean().0 {

                    self.eval(h, ctx, expr.true_expression)

                } else {

                    self.eval(h, ctx, expr.false_expression)

                }

            }

            Expression::Binary(expr) => {

                let left = self.eval(h, ctx, expr.left)?;

                match expr.operation {

                    BinaryOperator::Equality => Ok(left.eq(&right)),

                    BinaryOperator::Inequality => Ok(left.neq(&right)),

                    BinaryOperator::LessThan => Ok(left.lt(&right)),

                    BinaryOperator::LessThanEqual => Ok(left.lte(&right)),

                    BinaryOperator::GreaterThan => Ok(left.gt(&right)),

                    BinaryOperator::GreaterThanEqual => Ok(left.gte(&right)),

                    BinaryOperator::Remainder => Ok(left.modulus(&right)),

                }

            }

            Expression::Unary(expr) => {

                let mut value = self.eval(h, ctx, expr.expression)?;

                match expr.operation {

                    UnaryOperation::PostIncrement => {

                        self.update(h, ctx, expr.expression, value.plus(&ONE))?;

                    }

                    UnaryOperation::PreIncrement => {

                        value = value.plus(&ONE);

                        self.update(h, ctx, expr.expression, value.clone())?;

                    }

                    UnaryOperation::PostDecrement => {

                        self.update(h, ctx, expr.expression, value.minus(&ONE))?;

                    }

                    UnaryOperation::PreDecrement => {

                        value = value.minus(&ONE);

                        self.update(h, ctx, expr.expression, value.clone())?;

                    }

                    _ => unimplemented!(),

                }

                Ok(value)

            }

            Expression::Indexing(expr) => self.get(h, ctx, expr.this.upcast()),

            Expression::Slicing(expr) => unimplemented!(),

            Expression::Select(expr) => self.get(h, ctx, expr.this.upcast()),

            Expression::Array(expr) => {

                let mut elements = Vec::new();

                for &elem in expr.elements.iter() {

                    elements.push(self.eval(h, ctx, elem)?);

                }

                todo!()

            },

            Expression::Constant(expr) => Ok(Value::from_constant(&expr.value)),

            Expression::Call(expr) => match expr.method {

                Method::Create => {

                    assert_eq!(1, expr.arguments.len());

                    let length = self.eval(h, ctx, expr.arguments[0])?;

                    Ok(Value::create_message(length))

                }

                Method::Fires => {

                    assert_eq!(1, expr.arguments.len());

                    let value = self.eval(h, ctx, expr.arguments[0])?;

                    match ctx.fires(value.clone()) {

                        None => Err(EvalContinuation::BlockFires(value)),

                        Some(result) => Ok(result),

                    }

                }

        &|x| {

            // Receiver

            x.configure(PDL, b"sync").unwrap();

            x.bind_port(0, Active(addrs[0])).unwrap();

            x.bind_port(1, Native).unwrap();

            x.connect(timeout).unwrap();

            for _ in 0..N {

                // empty batch

                x.next_batch().unwrap();

                // got a message

                x.get(0).unwrap();

                match x.sync(timeout).unwrap() {

                    0 => assert_eq!(Err(ReadGottenErr::DidNotGet), x.read_gotten(0)),

                    1 => assert_ne!(Ok(&[] as &[u8]), x.read_gotten(0)),

                    _ => unreachable!(),

                }

            }

        },

    ]));

}

#[test]

fn fifo_1_e() {

    /*

        /-->\

    Alice   fifo_1

        \<--/

    */

    let timeout = Duration::from_millis(1_500);

    const N: usize = 10;

    assert!(run_connector_set(&[

        //

        &|x| {

            // Alice

            x.configure(PDL, b"fifo_1_e").unwrap();

            x.bind_port(0, Native).unwrap();

            x.bind_port(1, Native).unwrap();

            x.connect(timeout).unwrap();

            for _ in 0..N {

                // put

                assert_eq!(Ok(()), x.put(0, b"message~".to_vec()));

                assert_eq!(Ok(0), x.sync(timeout));

                // get

                assert_eq!(Ok(()), x.get(1));

                assert_eq!(Ok(0), x.sync(timeout));

            }

        },

    ]));

}