Add more goto tests and their expected output

Author: lucic71

tests/unit/goto_aggregate_default.c

@@ -0,0 +1,22 @@
+#include <assert.h>
+#include <string.h>
+
+static int agg(int n) {
+  char buf[40];
+  int total = 0;
+  if (n < 0) {
+    goto out;
+  }
+  memset(buf, 1, sizeof(buf));
+  for (int i = 0; i < 40; i++) {
+    total += buf[i];
+  }
+out:
+  return total;
+}
+
+int main(void) {
+  assert(agg(-1) == 0);
+  assert(agg(2) == 40);
+  return 0;
+}

tests/unit/goto_backward.c

@@ -0,0 +1,18 @@
+#include <assert.h>
+
+static int retry(int n) {
+  int count = 0;
+  int acc = 0;
+again:
+  count += 1;
+  acc += n;
+  if (count < 3) {
+    goto again;
+  }
+  return acc;
+}
+
+int main(void) {
+  assert(retry(4) == 12);
+  return 0;
+}

tests/unit/goto_cleanup.c

@@ -0,0 +1,51 @@
+#include <assert.h>
+
+static int early(int n) {
+  int ret = 0;
+  if (n < 0) {
+    ret = -1;
+    goto out;
+  }
+  ret = 100;
+out:
+  return ret;
+}
+
+static int from_loop(int n) {
+  int ret = 0;
+  for (int i = 0; i < n; i++) {
+    if (i == 3) {
+      ret = 7;
+      goto out;
+    }
+    ret += i;
+  }
+  ret = 999;
+out:
+  return ret;
+}
+
+static int from_switch(int n) {
+  int ret = 0;
+  switch (n) {
+  case 1:
+    ret = 10;
+    goto out;
+  default:
+    ret = 20;
+    break;
+  }
+  ret = 999;
+out:
+  return ret;
+}
+
+int main(void) {
+  assert(early(-1) == -1);
+  assert(early(5) == 100);
+  assert(from_loop(2) == 999);
+  assert(from_loop(10) == 7);
+  assert(from_switch(1) == 10);
+  assert(from_switch(2) == 999);
+  return 0;
+}

tests/unit/goto_forward_skip.c

@@ -0,0 +1,18 @@
+#include <assert.h>
+
+static int skip(int n) {
+  int x = 0;
+  if (n > 0) {
+    goto mid;
+  }
+  x += 10;
+mid:
+  x += 1;
+  return x;
+}
+
+int main(void) {
+  assert(skip(1) == 1);
+  assert(skip(-1) == 11);
+  return 0;
+}

tests/unit/goto_loop_control.c

@@ -0,0 +1,25 @@
+#include <assert.h>
+
+static int loopctl(int n) {
+  int total = 0;
+  for (int i = 0; i < n; i++) {
+    if (i == 2) {
+      continue;
+    }
+    if (i == 5) {
+      break;
+    }
+    if (i % 2 == 0) {
+      goto even;
+    }
+    total += 1;
+  even:
+    total += 10;
+  }
+  return total;
+}
+
+int main(void) {
+  assert(loopctl(10) == 42);
+  return 0;
+}

tests/unit/goto_multi_label.c

@@ -0,0 +1,24 @@
+#include <assert.h>
+
+static int classify(int n) {
+  int ret = 0;
+  if (n < 0) {
+    goto error;
+  }
+  if (n == 0) {
+    goto out;
+  }
+  ret = n;
+  goto out;
+error:
+  ret = -1;
+out:
+  return ret;
+}
+
+int main(void) {
+  assert(classify(5) == 5);
+  assert(classify(0) == 0);
+  assert(classify(-2) == -1);
+  return 0;
+}

tests/unit/goto_nested_label.c

@@ -0,0 +1,24 @@
+#include <assert.h>
+
+static int scan(int n) {
+  int total = 0;
+  for (int i = 0; i < n; i++) {
+    int j = 0;
+    while (j < 10) {
+      if (j == 5) {
+        goto next;
+      }
+      total += 1;
+      j++;
+    }
+    total += 100;
+  next:
+    total += 1000;
+  }
+  return total;
+}
+
+int main(void) {
+  assert(scan(2) == 2010);
+  return 0;
+}

tests/unit/goto_switch_exit.c

@@ -0,0 +1,26 @@
+#include <assert.h>
+
+static int classify(int n) {
+  int ret = 0;
+  switch (n) {
+  case 1:
+    ret = 10;
+    goto out;
+  case 2:
+    ret = 20;
+    break;
+  default:
+    ret = 30;
+    break;
+  }
+  ret += 1;
+out:
+  return ret;
+}
+
+int main(void) {
+  assert(classify(1) == 10);
+  assert(classify(2) == 21);
+  assert(classify(9) == 31);
+  return 0;
+}

tests/unit/goto_switch_fallthrough.c

@@ -0,0 +1,26 @@
+#include <assert.h>
+
+static int sm(int n) {
+  int ret = 0;
+  switch (n) {
+  case 0:
+    ret += 1;
+    /* fallthrough */
+  case 1:
+    ret += 10;
+    goto out;
+  default:
+    ret += 100;
+    break;
+  }
+  ret += 1000;
+out:
+  return ret;
+}
+
+int main(void) {
+  assert(sm(0) == 11);
+  assert(sm(1) == 10);
+  assert(sm(9) == 1100);
+  return 0;
+}

tests/unit/out/refcount/goto_aggregate_default.rs

@@ -0,0 +1,58 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn agg_0(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let mut buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..40).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    let mut total: Value<i32> = <Value<i32>>::default();
+    goto_block!({
+        '__entry: {
+            total = Rc::new(RefCell::new(0));
+            if ((((*n.borrow()) < 0) as i32) != 0) {
+                goto!('out);
+            }
+            {
+                ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                    .to_any()
+                    .memset((1) as u8, ::std::mem::size_of::<[u8; 40]>() as u64 as usize);
+                ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+            };
+            let i: Value<i32> = Rc::new(RefCell::new(0));
+            'loop_: while ((((*i.borrow()) < 40) as i32) != 0) {
+                (*total.borrow_mut()) += ((*buf.borrow())[(*i.borrow()) as usize] as i32);
+                (*i.borrow_mut()).postfix_inc();
+            }
+        }
+        'out: {
+            return (*total.borrow());
+        }
+    });
+    panic!("ub: non-void function does not return a value")
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!(
+        (((({
+            let _n: i32 = -1_i32;
+            agg_0(_n)
+        }) == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let _n: i32 = 2;
+            agg_0(_n)
+        }) == 40) as i32)
+            != 0)
+    );
+    return 0;
+}